diff --git a/ShengShengBuXi.ConsoleApp/Program.cs b/ShengShengBuXi.ConsoleApp/Program.cs
index 09b0fd5..54fab91 100644
--- a/ShengShengBuXi.ConsoleApp/Program.cs
+++ b/ShengShengBuXi.ConsoleApp/Program.cs
@@ -11,74 +11,6 @@ namespace ShengShengBuXi.ConsoleApp;
 
 public class Program
 {
-    private static readonly string AudioPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "mp3");
-    private static readonly ConcurrentDictionary<int, (WaveOutEvent Device, AudioFileReader Reader)> KeyToneDevices = new();
-    private static WaveOutEvent? waitingToneDevice;
-    private static AudioFileReader? waitingToneReader;
-    private static volatile bool isRecording = false;
-    private static DateTime lastKeyPressTime = DateTime.MinValue;
-    private static List<int> pressedKeys = new();
-    private static volatile bool isWaitingTonePlaying = false;
-    private static CancellationTokenSource? waitingToneCts;
-    private static readonly CancellationTokenSource programCts = new();
-    private static readonly HashSet<int> currentPressedKeys = new();
-    private static readonly Timer resetTimer;
-    private static readonly Timer dialOutTimer;
-
-    // Windows API
-    private const int WH_KEYBOARD_LL = 13;
-    private const int WM_KEYDOWN = 0x0100;
-    private const int WM_KEYUP = 0x0101;
-    private static IntPtr hookHandle = IntPtr.Zero;
-    private static HookProc? hookProc;
-
-    // 数字键盘的虚拟键码 (VK_NUMPAD0 - VK_NUMPAD9)
-    private static readonly int[] numpadKeys = Enumerable.Range(0x60, 10).ToArray();
-
-    // 回车键的虚拟键码
-    private const int VK_RETURN = 0x0D;
-
-    // 新增录音相关变量
-    private static WaveInEvent? waveIn = null;
-    private static WaveFileWriter? waveWriter = null;
-    private static string recordingFilePath = "";
-    private static DateTime lastSoundTime = DateTime.MinValue;
-    private static Timer? silenceTimer = null;
-    private static readonly float silenceThreshold = 0.02f; // 静音阈值
-    private static volatile bool isHangUpKeyPressed = false;
-
-    static Program()
-    {
-        resetTimer = new Timer(CheckResetTimeout, null, Timeout.Infinite, Timeout.Infinite);
-        dialOutTimer = new Timer(CheckDialOutTimeout, null, Timeout.Infinite, Timeout.Infinite);
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct KBDLLHOOKSTRUCT
-    {
-        public uint vkCode;
-        public uint scanCode;
-        public uint flags;
-        public uint time;
-        public IntPtr dwExtraInfo;
-    }
-
-    private delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
-
-    [DllImport("user32.dll")]
-    private static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, uint dwThreadId);
-
-    [DllImport("user32.dll")]
-    private static extern bool UnhookWindowsHookEx(IntPtr hhk);
-
-    [DllImport("user32.dll")]
-    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
-
-    [DllImport("kernel32.dll")]
-    private static extern IntPtr GetModuleHandle(string? lpModuleName);
-
-    [DllImport("user32.dll")]
-    private static extern short GetAsyncKeyState(int vKey);
 
     public static async Task Main(string[] args)
     {
@@ -88,17 +20,17 @@ public class Program
         {
             // 加载应用程序设置
             var appSettings = AppSettings.LoadFromFile("appsettings.json");
-            
+
             // 配置依赖注入
             var services = ConfigureServices(appSettings);
-            
+
             // 获取服务
             var phoneBoothService = services.GetRequiredService<IPhoneBoothService>();
             var signalRService = services.GetRequiredService<ISignalRService>();
-            
+
             // 初始化电话亭服务
             await phoneBoothService.InitializeAsync();
-            
+
             // 如果配置为自动连接，则连接到SignalR服务器
             if (appSettings.AutoConnectToServer)
             {
@@ -133,17 +65,17 @@ public class Program
                         await Task.Delay(1000);
                     }
                 }
-                
+
                 if (!connected && !appSettings.AllowOfflineStart)
                 {
                     Console.WriteLine("无法连接到服务器且不允许离线启动，程序将退出");
                     return;
                 }
             }
-            
+
             // 启动电话亭服务
             await phoneBoothService.StartAsync();
-            
+
             // 注册Ctrl+C处理
             var cts = new CancellationTokenSource();
             Console.CancelKeyPress += (s, e) =>
@@ -151,7 +83,7 @@ public class Program
                 e.Cancel = true;
                 cts.Cancel();
             };
-            
+
             // 等待程序退出信号
             try
             {
@@ -161,7 +93,7 @@ public class Program
             {
                 // 正常退出
             }
-            
+
             // 停止服务
             await phoneBoothService.StopAsync();
             await signalRService.StopConnectionAsync();
@@ -173,833 +105,24 @@ public class Program
             Console.ReadKey();
         }
     }
-    
+
     /// <summary>
     /// 配置依赖注入服务
     /// </summary>
     private static ServiceProvider ConfigureServices(AppSettings appSettings)
     {
         var services = new ServiceCollection();
-        
+
         // 注册配置
         services.AddSingleton(appSettings);
-        
+
         // 注册服务
         services.AddSingleton<IAudioFileService, AudioFileService>();
-        services.AddSingleton<ISignalRService>(provider => 
+        services.AddSingleton<ISignalRService>(provider =>
             new SignalRService(appSettings.ConfigBackupPath));
         services.AddSingleton<IPhoneBoothService, PhoneBoothService>();
-        
+
         return services.BuildServiceProvider();
     }
 
-    private static void InitializeAudioDevice()
-    {
-        try
-        {
-            waitingToneDevice = new WaveOutEvent();
-            waitingToneReader = new AudioFileReader(Path.Combine(AudioPath, "等待嘟音.wav"));
-            waitingToneDevice.Init(waitingToneReader);
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"初始化音频设备失败: {ex.Message}");
-            throw;
-        }
-    }
-
-    private static async Task StartKeyboardListener()
-    {
-        while (!programCts.Token.IsCancellationRequested)
-        {
-            try
-            {
-                // 检查回车键
-                bool isEnterPressed = (GetAsyncKeyState(VK_RETURN) & 0x8000) != 0;
-                if (isEnterPressed)
-                {
-                    // 添加一点延迟，防止连续检测到按键
-                    await Task.Delay(100, programCts.Token);
-
-                    // 再次检查回车键状态，确保不是误触或抖动
-                    bool stillPressed = (GetAsyncKeyState(VK_RETURN) & 0x8000) != 0;
-                    if (!stillPressed)
-                    {
-                        continue;
-                    }
-
-                    if (isRecording)
-                    {
-                        // 如果正在录音中，回车键被视为挂断信号
-                        Console.WriteLine("检测到回车键，用户挂断...");
-                        isHangUpKeyPressed = true;
-
-                        // 等待一段时间，防止重复触发
-                        await Task.Delay(500, programCts.Token);
-                        continue;
-                    }
-
-                    // 如果等待音正在播放，停止它
-                    if (isWaitingTonePlaying)
-                    {
-                        waitingToneCts?.Cancel();
-                        // 确保等待音停止
-                        while (isWaitingTonePlaying)
-                        {
-                            await Task.Delay(10);
-                        }
-                    }
-
-                    Console.WriteLine("检测到回车键，开始拨出...");
-
-                    // 非阻塞方式启动录音，不等待其完成
-                    _ = StartRecording();
-
-                    // 延迟防止重复触发
-                    await Task.Delay(500, programCts.Token);
-                    continue;
-                }
-
-                foreach (int key in numpadKeys)
-                {
-                    int digit = key - 0x60;  // 将虚拟键码转换为数字
-                    bool isKeyDown = (GetAsyncKeyState(key) & 0x8000) != 0;
-
-                    if (isKeyDown)
-                    {
-                        if (isRecording)
-                        {
-                            Console.WriteLine("正在录音中，无法点击按键...");
-                            await Task.Delay(1000, programCts.Token);
-                            continue;
-                        }
-                        if (!currentPressedKeys.Contains(digit))
-                        {
-                            Console.WriteLine($"按下数字键: {digit}");
-                            currentPressedKeys.Add(digit);
-                            await HandleDigitKeyPress(digit);
-                        }
-                    }
-                    else
-                    {
-                        if (currentPressedKeys.Contains(digit))
-                        {
-                            Console.WriteLine($"释放数字键: {digit}");
-                            currentPressedKeys.Remove(digit);
-                            await HandleDigitKeyRelease(digit);
-                        }
-                    }
-                }
-
-                await Task.Delay(10, programCts.Token);  // 降低CPU使用率
-            }
-            catch (OperationCanceledException)
-            {
-                break;
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"键盘监听出错: {ex.Message}");
-            }
-        }
-    }
-
-    private static async Task StartPlayingWaitingTone()
-    {
-        try
-        {
-            waitingToneCts?.Cancel();
-            waitingToneCts?.Dispose();
-            waitingToneCts = CancellationTokenSource.CreateLinkedTokenSource(programCts.Token);
-
-            var token = waitingToneCts.Token;
-            isWaitingTonePlaying = true;
-
-            while (!token.IsCancellationRequested)
-            {
-                try
-                {
-                    if (waitingToneReader?.Position >= waitingToneReader?.Length)
-                    {
-                        waitingToneReader.Position = 0;
-                    }
-                    waitingToneDevice?.Play();
-                    await Task.Delay(100, token);
-                }
-                catch (OperationCanceledException)
-                {
-                    break;
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"播放等待音失败: {ex.Message}");
-        }
-        finally
-        {
-            isWaitingTonePlaying = false;
-            waitingToneDevice?.Stop();
-        }
-    }
-
-    private static async Task HandleDigitKeyPress(int digit)
-    {
-        try
-        {
-            // 记录按键
-            pressedKeys.Add(digit);
-            lastKeyPressTime = DateTime.Now;
-            Console.WriteLine($"按下数字键: {digit}, 当前已按键数: {pressedKeys.Count}");
-
-            // 如果是第一个按键，停止等待音
-            if (pressedKeys.Count == 1 && isWaitingTonePlaying)
-            {
-                waitingToneCts?.Cancel();
-            }
-
-            // 播放按键音
-            await PlayKeyTone(digit);
-
-            // 重置定时器
-            resetTimer.Change(10000, Timeout.Infinite);  // 10秒后检查是否需要重置
-
-            // 检查是否需要拨出（8位以上且5秒内无新按键）
-            if (pressedKeys.Count >= 8)
-            {
-                // 重置拨出定时器，5秒后检查是否需要拨出
-                dialOutTimer.Change(5000, Timeout.Infinite);
-            }
-            else
-            {
-                // 如果位数不足8位，停止拨出定时器
-                dialOutTimer.Change(Timeout.Infinite, Timeout.Infinite);
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"处理按键 {digit} 失败: {ex.Message}");
-        }
-    }
-
-    private static void CheckResetTimeout(object? state)
-    {
-        try
-        {
-            // 如果正在录音中，不执行重置操作
-            if (isRecording)
-            {
-                return;
-            }
-
-            if (pressedKeys.Count > 0 && pressedKeys.Count < 8 &&
-                (DateTime.Now - lastKeyPressTime).TotalSeconds >= 10)
-            {
-                Console.WriteLine("10秒内未完成8位数字输入，重置等待...");
-                pressedKeys.Clear();
-                KeyToneDevices.Clear();
-                _ = StartPlayingWaitingTone();
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"检查超时重置失败: {ex.Message}");
-        }
-    }
-
-    private static void CheckDialOutTimeout(object? state)
-    {
-        try
-        {
-            // 如果正在录音中，不执行拨出操作
-            if (isRecording)
-            {
-                return;
-            }
-
-            // 检查是否已经过了5秒且按键数大于等于8
-            if (pressedKeys.Count >= 8 && (DateTime.Now - lastKeyPressTime).TotalSeconds >= 5)
-            {
-                Console.WriteLine("5秒内无新按键，开始拨出...");
-                // 非阻塞方式启动录音
-                _ = StartRecording();
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"检查拨出超时失败: {ex.Message}");
-        }
-    }
-
-    private static async Task HandleDigitKeyRelease(int digit)
-    {
-        try
-        {
-            if (KeyToneDevices.TryRemove(digit, out var deviceInfo))
-            {
-                deviceInfo.Device.Stop();
-                deviceInfo.Device.Dispose();
-                deviceInfo.Reader.Dispose();
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"处理按键 {digit} 释放失败: {ex.Message}");
-        }
-    }
-
-    private static async Task PlayKeyTone(int digit)
-    {
-        try
-        {
-            if (KeyToneDevices.ContainsKey(digit))
-            {
-                return; // 已经在播放中
-            }
-
-            var device = new WaveOutEvent();
-            var reader = new AudioFileReader(Path.Combine(AudioPath, $"{digit}.mp3"));
-            device.Init(reader);
-
-            if (KeyToneDevices.TryAdd(digit, (device, reader)))
-            {
-                device.Play();
-            }
-            else
-            {
-                device.Dispose();
-                reader.Dispose();
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"播放按键音 {digit} 失败: {ex.Message}");
-        }
-    }
-
-    private static async Task StartRecording()
-    {
-        // 创建一个CancellationTokenSource用于取消整个录音流程
-        using var recordingCts = CancellationTokenSource.CreateLinkedTokenSource(programCts.Token);
-
-        // 创建一个单独的任务来监视挂断信号
-        var hangupMonitorTask = Task.Run(async () =>
-        {
-            while (!recordingCts.Token.IsCancellationRequested)
-            {
-                // 检查是否收到挂断信号
-                if (isHangUpKeyPressed)
-                {
-                    Console.WriteLine("录音流程中检测到挂断信号，即将终止流程...");
-                    recordingCts.Cancel();
-                    break;
-                }
-                await Task.Delay(50);
-            }
-        });
-
-        try
-        {
-            // 进入录音状态，停止所有定时器
-            isRecording = true;
-            isHangUpKeyPressed = false;
-            resetTimer.Change(Timeout.Infinite, Timeout.Infinite);
-            dialOutTimer.Change(Timeout.Infinite, Timeout.Infinite);
-
-            // 确保等待音已停止
-            if (isWaitingTonePlaying)
-            {
-                waitingToneCts?.Cancel();
-                // 等待等待音实际停止
-                while (isWaitingTonePlaying && !recordingCts.Token.IsCancellationRequested)
-                {
-                    await Task.Delay(10);
-                }
-            }
-
-            // 如果已经收到取消信号，立即结束
-            if (recordingCts.Token.IsCancellationRequested)
-            {
-                throw new OperationCanceledException("录音流程被用户取消");
-            }
-
-            Console.WriteLine("开始录音流程...");
-
-            // 随机播放3-6秒的等待接电话音频
-            int waitTime = new Random().Next(3, 7); // 3到6秒
-            Console.WriteLine($"播放等待接电话音频，持续{waitTime}秒...");
-
-            try
-            {
-                await PlayAudioAndWait(Path.Combine(AudioPath, "等待接电话.mp3"), waitTime * 1000, true, recordingCts.Token);
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-
-            // 如果已经收到取消信号，立即结束
-            if (recordingCts.Token.IsCancellationRequested)
-            {
-                throw new OperationCanceledException("录音流程被用户取消");
-            }
-
-            // 15%概率播放电话接起音频
-            bool playPickup = new Random().NextDouble() < 0.15;
-            if (playPickup)
-            {
-                Console.WriteLine("播放电话接起音频...");
-                try
-                {
-                    await PlayAudioAndWait(Path.Combine(AudioPath, "电话接起.mp3"), null, false, recordingCts.Token);
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-
-                if (recordingCts.Token.IsCancellationRequested)
-                {
-                    throw new OperationCanceledException("录音流程被用户取消");
-                }
-            }
-
-            // 播放提示用户录音的音频
-            Console.WriteLine("播放提示用户录音音频...");
-            try
-            {
-                await PlayAudioAndWait(Path.Combine(AudioPath, "提示用户录音.mp3"), null, false, recordingCts.Token);
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-
-            if (recordingCts.Token.IsCancellationRequested)
-            {
-                throw new OperationCanceledException("录音流程被用户取消");
-            }
-
-            // 开始实际录音逻辑
-            Console.WriteLine("开始初始化录音设备...");
-
-            // 创建录音文件路径
-            string recordingsFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "recordings");
-            if (!Directory.Exists(recordingsFolder))
-            {
-                Directory.CreateDirectory(recordingsFolder);
-            }
-
-            recordingFilePath = Path.Combine(recordingsFolder, $"recording_{DateTime.Now:yyyyMMdd_HHmmss}.wav");
-
-            // 初始化录音设备
-            await StartAudioRecording(recordingFilePath);
-
-            if (recordingCts.Token.IsCancellationRequested)
-            {
-                throw new OperationCanceledException("录音流程被用户取消");
-            }
-
-            // 创建一个等待完成的任务源
-            var recordingCompletionSource = new TaskCompletionSource<bool>();
-
-            // 启动静音检测计时器
-            lastSoundTime = DateTime.Now;
-            silenceTimer = new Timer(CheckSilence, recordingCompletionSource, 1000, 1000);
-
-            Console.WriteLine("播放滴提示音...");
-            try
-            {
-                await PlayAudioAndWait(Path.Combine(AudioPath, "滴提示音.wav"), null, false, recordingCts.Token);
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-
-            if (recordingCts.Token.IsCancellationRequested)
-            {
-                throw new OperationCanceledException("录音流程被用户取消");
-            }
-
-            Console.WriteLine("开始录制用户声音...");
-
-            // 创建一个任务等待录音结束（通过静音检测、挂断按键或取消）
-            var recordingTask = Task.Run(async () =>
-            {
-                try
-                {
-                    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(recordingCts.Token);
-
-                    // 注册取消处理程序
-                    linkedCts.Token.Register(() =>
-                    {
-                        recordingCompletionSource.TrySetResult(true);
-                    });
-
-                    // 等待录音完成
-                    await recordingCompletionSource.Task;
-                }
-                catch (Exception)
-                {
-                    // 捕获所有异常，确保不会中断主流程
-                }
-            });
-
-            // 等待录音完成或取消
-            try
-            {
-                await Task.WhenAny(recordingTask, Task.Delay(Timeout.Infinite, recordingCts.Token));
-            }
-            catch (OperationCanceledException)
-            {
-                // 预期的取消异常，可以忽略
-            }
-
-            // 停止录音
-            StopAudioRecording();
-
-            Console.WriteLine("录音结束，重置状态...");
-
-            // 完全重置系统状态
-            CompletelyResetState();
-
-            Console.WriteLine("系统已重置，可以继续使用...");
-        }
-        catch (OperationCanceledException ex)
-        {
-            Console.WriteLine($"录音流程被取消: {ex.Message}");
-
-            // 确保录音设备被释放
-            StopAudioRecording();
-
-            // 取消时也完全重置系统状态
-            CompletelyResetState();
-
-            Console.WriteLine("系统已重置，可以继续使用...");
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"录音过程发生错误: {ex.Message}");
-
-            // 确保录音设备被释放
-            StopAudioRecording();
-
-            // 发生错误时也完全重置系统状态
-            CompletelyResetState();
-        }
-    }
-
-    private static void CheckSilence(object? state)
-    {
-        try
-        {
-            var completionSource = state as TaskCompletionSource<bool>;
-
-            // 如果用户按了回车键，立即结束录音
-            if (isHangUpKeyPressed)
-            {
-                Console.WriteLine("定时器检测到用户手动挂断");
-                completionSource?.TrySetResult(true);
-                return;
-            }
-
-            // 检查是否超过30秒没有声音
-            if ((DateTime.Now - lastSoundTime).TotalSeconds >= 30)
-            {
-                Console.WriteLine("检测到30秒无声音，自动挂断");
-                completionSource?.TrySetResult(true);
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"静音检测错误: {ex.Message}");
-        }
-    }
-
-    private static async Task StartAudioRecording(string filePath)
-    {
-        try
-        {
-            // 创建录音设备
-            waveIn = new WaveInEvent
-            {
-                DeviceNumber = 0, // 使用默认录音设备
-                WaveFormat = new WaveFormat(16000, 1), // 16 kHz, 单声道
-                BufferMilliseconds = 100  //音频缓冲区的大小（以毫秒为单位）。这个参数控制着音频数据从麦克风读取并触发 DataAvailable 事件的频率。
-            };
-
-            // 创建文件写入器
-            waveWriter = new WaveFileWriter(filePath, waveIn.WaveFormat);
-
-            // 处理录音数据
-            waveIn.DataAvailable += (s, e) =>
-            {
-                try
-                {
-                    // 将数据写入文件
-                    waveWriter.Write(e.Buffer, 0, e.BytesRecorded);
-
-                    // 检查是否有声音
-                    if (HasSound(e.Buffer, e.BytesRecorded))
-                    {
-                        lastSoundTime = DateTime.Now;
-                    }
-                }
-                catch (Exception ex)
-                {
-                    Console.WriteLine($"录音数据处理错误: {ex.Message}");
-                }
-            };
-
-            // 录音完成事件
-            waveIn.RecordingStopped += (s, e) =>
-            {
-                // 在这里处理录音停止后的逻辑
-                Console.WriteLine("录音已停止");
-            };
-
-            // 开始录音
-            waveIn.StartRecording();
-            Console.WriteLine($"开始录音，保存到文件: {filePath}");
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"启动录音失败: {ex.Message}");
-            throw;
-        }
-    }
-
-    private static void StopAudioRecording()
-    {
-        try
-        {
-            // 停止静音检测计时器
-            silenceTimer?.Change(Timeout.Infinite, Timeout.Infinite);
-            silenceTimer?.Dispose();
-            silenceTimer = null;
-
-            // 停止录音
-            if (waveIn != null)
-            {
-                waveIn.StopRecording();
-                waveIn.Dispose();
-                waveIn = null;
-            }
-
-            // 关闭文件
-            if (waveWriter != null)
-            {
-                waveWriter.Dispose();
-                waveWriter = null;
-
-                Console.WriteLine($"录音已保存到: {recordingFilePath}");
-            }
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"停止录音失败: {ex.Message}");
-        }
-    }
-
-    private static bool HasSound(byte[] buffer, int bytesRecorded)
-    {
-        // 将字节数组转换为浮点数数组以计算音量
-        float maxVolume = 0;
-
-        // 对于16位PCM数据
-        for (int i = 0; i < bytesRecorded; i += 2)
-        {
-            if (i + 1 < bytesRecorded)
-            {
-                // 将两个字节转换为short（16位）
-                short sample = (short)((buffer[i + 1] << 8) | buffer[i]);
-
-                // 转换为-1.0到1.0范围内的浮点数
-                float normSample = sample / 32768.0f;
-
-                // 取绝对值并更新最大音量
-                float absSample = Math.Abs(normSample);
-                if (absSample > maxVolume)
-                {
-                    maxVolume = absSample;
-                }
-            }
-        }
-
-        // 如果最大音量超过阈值，则认为有声音
-        return maxVolume > silenceThreshold;
-    }
-
-    private static async void CompletelyResetState()
-    {
-        try
-        {
-            // 确保录音设备被释放
-            StopAudioRecording();
-
-            // 清除录音状态
-            isRecording = false;
-            isHangUpKeyPressed = false;
-
-            // 清除按键记录
-            pressedKeys.Clear();
-            currentPressedKeys.Clear();
-
-            // 停止所有按键音
-            foreach (var (digit, deviceInfo) in KeyToneDevices.ToArray())
-            {
-                try
-                {
-                    KeyToneDevices.TryRemove(digit, out _);
-                    deviceInfo.Device.Stop();
-                    deviceInfo.Device.Dispose();
-                    deviceInfo.Reader.Dispose();
-                }
-                catch (Exception ex)
-                {
-                    Console.WriteLine($"清理按键音设备失败: {ex.Message}");
-                }
-            }
-
-            // 重新开始播放等待音
-            _ = StartPlayingWaitingTone();
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"重置状态失败: {ex.Message}");
-
-            // 最后的保障措施
-            isRecording = false;
-            isHangUpKeyPressed = false;
-            pressedKeys.Clear();
-            currentPressedKeys.Clear();
-            KeyToneDevices.Clear();
-
-            // 尝试重新开始播放等待音
-            try
-            {
-                _ = StartPlayingWaitingTone();
-            }
-            catch
-            {
-                // 忽略任何错误
-            }
-        }
-    }
-
-    private static async Task
-    PlayAudioAndWait(string audioPath, int? maxDuration = null, bool loop = false, CancellationToken token = default)
-    {
-        WaveOutEvent device = null;
-        AudioFileReader reader = null;
-
-        try
-        {
-            device = new WaveOutEvent();
-            reader = new AudioFileReader(audioPath);
-            device.Init(reader);
-
-            // 如果需要循环播放，创建一个循环播放的任务
-            if (loop && maxDuration.HasValue)
-            {
-                var startTime = DateTime.Now;
-                var endTime = startTime.AddMilliseconds(maxDuration.Value);
-
-                // 开始播放
-                device.Play();
-
-                // 循环播放直到达到指定时间
-                while (DateTime.Now < endTime && !token.IsCancellationRequested)
-                {
-                    // 如果到达文件末尾，重新开始播放
-                    if (reader.Position >= reader.Length)
-                    {
-                        reader.Position = 0;
-                    }
-
-                    // 如果没有在播放中，重新开始播放
-                    if (device.PlaybackState != PlaybackState.Playing)
-                    {
-                        reader.Position = 0;
-                        device.Play();
-                    }
-
-                    // 短暂等待，避免CPU占用过高
-                    await Task.Delay(50, token);
-                }
-
-                // 时间到，停止播放
-                device.Stop();
-            }
-            else if (maxDuration.HasValue)
-            {
-                // 开始播放
-                device.Play();
-
-                // 等待指定时间
-                await Task.Delay(maxDuration.Value, token);
-
-                // 时间到，停止播放
-                device.Stop();
-            }
-            else
-            {
-                // 创建一个TaskCompletionSource等待播放完成
-                var completionSource = new TaskCompletionSource<bool>();
-
-                // 一次性事件处理，播放完成后设置结果
-                EventHandler<StoppedEventArgs> handler = null;
-                handler = (s, e) =>
-                {
-                    device.PlaybackStopped -= handler;
-                    completionSource.TrySetResult(true);
-                };
-
-                device.PlaybackStopped += handler;
-                device.Play();
-
-                // 注册取消操作
-                using var registration = token.Register(() =>
-                {
-                    device.Stop();
-                    completionSource.TrySetCanceled(token);
-                });
-
-                // 等待播放完成或取消
-                await completionSource.Task;
-            }
-        }
-        catch (Exception ex)
-        {
-            if (token.IsCancellationRequested)
-            {
-                // 如果是取消引起的异常，重新抛出OperationCanceledException
-                throw new OperationCanceledException("播放音频被用户取消", ex, token);
-            }
-            Console.WriteLine($"播放音频失败: {ex.Message}");
-        }
-        finally
-        {
-            device?.Stop();
-            device?.Dispose();
-            reader?.Dispose();
-        }
-    }
-
-    private static void DisposeAudioDevices()
-    {
-        waitingToneCts?.Cancel();
-        waitingToneCts?.Dispose();
-
-        waitingToneDevice?.Dispose();
-        waitingToneReader?.Dispose();
-
-        foreach (var (device, reader) in KeyToneDevices.Values)
-        {
-            device.Dispose();
-            reader.Dispose();
-        }
-        KeyToneDevices.Clear();
-    }
 }
diff --git a/ShengShengBuXi.ConsoleApp/Services/PhoneBoothService.cs b/ShengShengBuXi.ConsoleApp/Services/PhoneBoothService.cs
index f9a01c8..328d455 100644
--- a/ShengShengBuXi.ConsoleApp/Services/PhoneBoothService.cs
+++ b/ShengShengBuXi.ConsoleApp/Services/PhoneBoothService.cs
@@ -531,25 +531,6 @@ public class PhoneBoothService : IPhoneBoothService, IDisposable
                     throw new OperationCanceledException("录音流程被用户取消");
                 }
             }
-
-            // 播放提示用户录音的音频
-            Console.WriteLine("播放提示用户录音音频...");
-            try
-            {
-                await PlayAudioAndWait(
-                    _config.AudioFiles.GetFullPath(_config.AudioFiles.PromptUserRecordFile),
-                    null, false, recordingCts.Token);
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-
-            if (recordingCts.Token.IsCancellationRequested)
-            {
-                throw new OperationCanceledException("录音流程被用户取消");
-            }
-
             // 开始实际录音逻辑
             Console.WriteLine("开始初始化录音设备...");
 
@@ -570,7 +551,27 @@ public class PhoneBoothService : IPhoneBoothService, IDisposable
             Console.WriteLine("正在初始化录音设备...");
             // 初始化录音设备
             await StartAudioRecording(_recordingFilePath);
-            Console.WriteLine("正在录音中...");
+            Console.WriteLine("录音开始...");
+
+            if (recordingCts.Token.IsCancellationRequested)
+            {
+                throw new OperationCanceledException("录音流程被用户取消");
+            }
+
+            // 播放提示用户录音的音频
+            Console.WriteLine("播放提示用户录音音频...");
+            try
+            {
+                await PlayAudioAndWait(
+                    _config.AudioFiles.GetFullPath(_config.AudioFiles.PromptUserRecordFile),
+                    null, false, recordingCts.Token);
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+
+
             if (recordingCts.Token.IsCancellationRequested)
             {
                 throw new OperationCanceledException("录音流程被用户取消");
@@ -961,7 +962,7 @@ public class PhoneBoothService : IPhoneBoothService, IDisposable
             {
                 Console.WriteLine("检测到用户说话，停止风铃声...");
                 _ = StopWindChime(true); // 平滑淡出
-                
+
                 // 风铃声停止后，重新启动背景音乐
                 if (!_isBackgroundMusicPlaying && _config.Recording.EnableBackgroundMusic)
                 {
@@ -1547,7 +1548,7 @@ public class PhoneBoothService : IPhoneBoothService, IDisposable
                     {
                         _backgroundMusicReader.Position = 0;
                     }
-                    
+
                     // 如果没有在播放，则开始播放
                     if (_backgroundMusicDevice.PlaybackState != PlaybackState.Playing)
                     {
@@ -1639,13 +1640,13 @@ public class PhoneBoothService : IPhoneBoothService, IDisposable
                 !_isWindChimePlaying)
             {
                 Console.WriteLine($"检测到{windChimePromptSeconds}秒无声音，先停止背景音乐，再播放风铃提示音...");
-                
+
                 // 先停止背景音乐
                 if (_isBackgroundMusicPlaying)
                 {
                     StopBackgroundMusic();
                 }
-                
+
                 // 然后播放风铃提示音
                 _ = PlayWindChime();
             }
@@ -1772,14 +1773,14 @@ public class PhoneBoothService : IPhoneBoothService, IDisposable
 
                     float ratio = 1.0f - ((float)i / steps);
                     _windChimeDevice.Volume = startVolume * ratio;
-                    
+
                     await Task.Delay(stepDelay);
                 }
             }
 
             // 正式停止
             _windChimeCts?.Cancel();
-            
+
             if (_windChimeDevice != null)
             {
                 _windChimeDevice.Stop();
diff --git a/ShengShengBuXi.ConsoleApp/appsettings.json b/ShengShengBuXi.ConsoleApp/appsettings.json
index 7700478..f1dd3dd 100644
--- a/ShengShengBuXi.ConsoleApp/appsettings.json
+++ b/ShengShengBuXi.ConsoleApp/appsettings.json
@@ -1,5 +1,5 @@
 {
-  "SignalRHubUrl": "http://115.159.44.16/audiohub",
+  "SignalRHubUrl": "http://localhost:81/audiohub",
   "ConfigBackupPath": "config.json",
   "AutoConnectToServer": true,
   "AllowOfflineStart": false
diff --git a/ShengShengBuXi/Hubs/AudioHub.cs b/ShengShengBuXi/Hubs/AudioHub.cs
index 7dc97f8..bb923dc 100644
--- a/ShengShengBuXi/Hubs/AudioHub.cs
+++ b/ShengShengBuXi/Hubs/AudioHub.cs
@@ -29,6 +29,9 @@ namespace ShengShengBuXi.Hubs
         private readonly IAudioProcessingService _audioProcessingService;
         private readonly IConfigurationService _configurationService;
         private readonly ISpeechToTextService _speechToTextService;
+        /// <summary>
+        /// 客户端列表
+        /// </summary>
         private static readonly ConcurrentDictionary<string, ClientInfo> _clients = new ConcurrentDictionary<string, ClientInfo>();
         private readonly ILogger<AudioHub> _logger;
         private readonly IHubContext<AudioHub> _hubContext;
@@ -42,6 +45,8 @@ namespace ShengShengBuXi.Hubs
         /// 用于清理过期记录的计时器
         /// </summary>
         private static Timer _cleanupTimer;
+        // 管理员配置保存路径
+        private static readonly string ConfigDirectory = Path.Combine(Directory.GetCurrentDirectory(), "config");
 
 
         private static bool isInitialized = false;
@@ -78,30 +83,48 @@ namespace ShengShengBuXi.Hubs
         /// <summary>
         /// 监控文本队列的持久化文件路径
         /// </summary>
-        private static readonly string _monitorTextQueueFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config/monitor_text_queue.json");
+        private static readonly string _monitorTextQueueFilePath = Path.Combine(ConfigDirectory, "monitor_text_queue.json");
         /// <summary>
         /// 预设句子文件路径
         /// </summary>
-        private static readonly string _sentencesFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config/sentences.txt");
+        private static readonly string _sentencesFilePath = Path.Combine(ConfigDirectory, "sentences.txt");
         /// <summary>
         /// 真实用户显示记录的持久化文件路径
         /// </summary>
-        private static readonly string _realUserDisplayLogsPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config/real_user_displays.log");
+        private static readonly string _realUserDisplayLogsPath = Path.Combine(ConfigDirectory, "real_user_displays.log");
         /// <summary>
         /// 预设句子列表
         /// </summary>
         private static List<string> _presetSentences = new List<string>();
 
+        /// <summary>
+        /// 预设句子2文件路径
+        /// </summary>
+        private static readonly string _sentences2FilePath = Path.Combine(ConfigDirectory, "sentences2.txt");
+
+        /// <summary>
+        /// 预设句子2列表
+        /// </summary>
+        private static List<string> _presetSentences2 = new List<string>();
+
+        /// <summary>
+        /// 当前使用的预设句子类型 (0: 默认预设句子, 1: 预设句子2)
+        /// </summary>
+        private static int _currentPresetSentenceType = 0;
+        /// <summary>
+        /// 预设句子类型配置文件路径
+        /// </summary>
+        private static readonly string _presetSentenceConfigPath = Path.Combine(ConfigDirectory, "newconfig.js");
+
         // 配置信息
         private static string _displayConfig = "{}";
         private static object _displayConfigLock = new object();
 
         // 控屏开关设置
         private static bool _manualScreenControlEnabled = false;
-        private static readonly string _screenControlSettingPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config/screen_control.json");
+        private static readonly string _screenControlSettingPath = Path.Combine(ConfigDirectory, "screen_control.json");
+
 
-        // 管理员配置保存路径
-        private static readonly string ConfigDirectory = Path.Combine(Directory.GetCurrentDirectory(), "config");
         private static readonly string DisplayConfigPath = Path.Combine(ConfigDirectory, "display.json");
 
         private static DateTime _lastRealTimeResultSentTime = DateTime.MinValue;
@@ -129,6 +152,15 @@ namespace ShengShengBuXi.Hubs
 
             // 加载控屏设置
             LoadScreenControlSetting();
+
+            // 加载预设句子类型设置
+            LoadPresetSentenceTypeSetting();
+
+            // 加载预设句子
+            LoadPresetSentencesFromFile();
+
+            // 加载预设句子2
+            LoadPresetSentences2FromFile();
         }
 
         // 加载显示配置
@@ -235,6 +267,51 @@ namespace ShengShengBuXi.Hubs
             }
         }
 
+        // 加载预设句子类型设置
+        private static void LoadPresetSentenceTypeSetting()
+        {
+            try
+            {
+                if (File.Exists(_presetSentenceConfigPath))
+                {
+                    string json = File.ReadAllText(_presetSentenceConfigPath);
+                    var setting = JsonConvert.DeserializeObject<dynamic>(json);
+                    _currentPresetSentenceType = setting?.Type ?? 0;
+                    Console.WriteLine($"加载预设句子类型设置成功，当前类型: {_currentPresetSentenceType}");
+                }
+                else
+                {
+                    // 默认使用类型0
+                    _currentPresetSentenceType = 0;
+
+                    // 保存默认设置
+                    SavePresetSentenceTypeSetting();
+                    Console.WriteLine("创建默认预设句子类型设置成功");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"加载预设句子类型设置出错: {ex.Message}");
+                _currentPresetSentenceType = 0;
+            }
+        }
+
+        // 保存预设句子类型设置
+        private static bool SavePresetSentenceTypeSetting()
+        {
+            try
+            {
+                string json = JsonConvert.SerializeObject(new { Type = _currentPresetSentenceType });
+                File.WriteAllText(_presetSentenceConfigPath, json);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"保存预设句子类型设置出错: {ex.Message}");
+                return false;
+            }
+        }
+
         /// <summary>
         /// 初始化音频Hub
         /// </summary>
@@ -591,7 +668,8 @@ namespace ShengShengBuXi.Hubs
                             // 添加音频数据发送任务，使用单独的客户端连接
                             // 使用清晰的对象格式，并添加WAV头以确保格式正确
                             var wavData = _audioProcessingService.AddWavHeader(dataToSend, config.SampleRate, config.Channels);
-                            tasks.Add(Clients.Client(clientId).SendAsync("ReceiveAudioData", new {
+                            tasks.Add(Clients.Client(clientId).SendAsync("ReceiveAudioData", new
+                            {
                                 format = "WAV",
                                 sampleRate = config.SampleRate,
                                 channels = config.Channels,
@@ -841,6 +919,8 @@ namespace ShengShengBuXi.Hubs
                 Text = text,
                 Timestamp = DateTime.Now
             });
+            _presetSentences.Add(text);
+            _presetSentences2.Add(text);
             return false;
         }
 
@@ -1090,6 +1170,13 @@ namespace ShengShengBuXi.Hubs
                     return;
                 }
 
+                if (highestPriority.Value.Text.Contains("青竹园"))
+                {
+                    if (_displayTextQueue.TryRemove(highestPriority.Key, out _))
+                    {
+                    }
+                    return;
+                }
 
                 // 在手动控屏模式下，只处理真实用户的消息
                 if (_manualScreenControlEnabled && !highestPriority.Value.IsRealUser)
@@ -1137,19 +1224,44 @@ namespace ShengShengBuXi.Hubs
         {
             try
             {
-                // 确保预设句子列表不为空
-                if (_presetSentences.Count == 0)
-                {
-                    LoadPresetSentencesFromFile();
+                // 根据当前预设句子类型选择使用哪个预设句子列表
+                List<string> currentPresetSentences;
 
-                    // 如果加载后仍然为空，使用默认句子
+                if (_currentPresetSentenceType == 1)
+                {
+                    // 使用预设句子2
+                    if (_presetSentences2.Count == 0)
+                    {
+                        LoadPresetSentences2FromFile();
+
+                        // 如果加载后仍然为空，使用默认句子
+                        if (_presetSentences2.Count == 0)
+                        {
+                            _presetSentences2.Add("每一次跨越山川，都是为了与你重逢。");
+                            _presetSentences2.Add("星光璀璨的夜晚，我想起了你的笑容。");
+                        }
+                    }
+                    currentPresetSentences = _presetSentences2;
+                }
+                else
+                {
+                    // 使用默认预设句子
                     if (_presetSentences.Count == 0)
                     {
-                        _presetSentences.Add("记得每到夏天傍晚，您就摇着蒲扇坐在藤椅里，把切好的西瓜最甜那块硬塞给我。");
-                        _presetSentences.Add("时光匆匆流逝，思念却越来越深。");
+                        LoadPresetSentencesFromFile();
+
+                        // 如果加载后仍然为空，使用默认句子
+                        if (_presetSentences.Count == 0)
+                        {
+                            _presetSentences.Add("记得每到夏天傍晚，您就摇着蒲扇坐在藤椅里，把切好的西瓜最甜那块硬塞给我。");
+                            _presetSentences.Add("时光匆匆流逝，思念却越来越深。");
+                        }
                     }
+                    currentPresetSentences = _presetSentences;
                 }
-                _presetSentences.OrderBy(it => Guid.NewGuid()).ToList().ForEach(item =>
+
+                // 随机排序并添加到显示队列
+                currentPresetSentences.OrderBy(it => Guid.NewGuid()).ToList().ForEach(item =>
                 {
                     var displayText = new DisplayText
                     {
@@ -1173,7 +1285,7 @@ namespace ShengShengBuXi.Hubs
         /// <summary>
         /// 从文件加载预设句子
         /// </summary>
-        private void LoadPresetSentencesFromFile()
+        private static void LoadPresetSentencesFromFile()
         {
             try
             {
@@ -1182,7 +1294,7 @@ namespace ShengShengBuXi.Hubs
                 // 检查文件是否存在
                 if (!File.Exists(_sentencesFilePath))
                 {
-                    _logger.LogWarning($"预设句子文件不存在: {_sentencesFilePath}，将创建默认文件");
+                    Console.WriteLine($"预设句子文件不存在: {_sentencesFilePath}，将创建默认文件");
 
                     // 创建目录（如果不存在）
                     Directory.CreateDirectory(Path.GetDirectoryName(_sentencesFilePath));
@@ -1204,11 +1316,53 @@ namespace ShengShengBuXi.Hubs
                     }
                 }
                 _presetSentences = _presetSentences.OrderBy(x => Guid.NewGuid()).ToList();
-                _logger.LogInformation($"成功从文件加载预设句子: {_presetSentences.Count} 条");
+                Console.WriteLine($"成功从文件加载预设句子: {_presetSentences.Count} 条");
             }
             catch (Exception ex)
             {
-                _logger.LogError($"加载预设句子失败: {ex.Message}");
+                Console.WriteLine($"加载预设句子失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 从文件加载预设句子2
+        /// </summary>
+        private static void LoadPresetSentences2FromFile()
+        {
+            try
+            {
+                _presetSentences2.Clear();
+
+                // 检查文件是否存在
+                if (!File.Exists(_sentences2FilePath))
+                {
+                    Console.WriteLine($"预设句子2文件不存在: {_sentences2FilePath}，将创建默认文件");
+
+                    // 创建目录（如果不存在）
+                    Directory.CreateDirectory(Path.GetDirectoryName(_sentences2FilePath));
+
+                    // 写入默认的预设句子2
+                    File.WriteAllLines(_sentences2FilePath, new string[] {
+
+                    });
+                }
+
+                // 读取文件中的每一行作为一个预设句子
+                string[] lines = File.ReadAllLines(_sentences2FilePath);
+                foreach (string line in lines)
+                {
+                    // 忽略空行
+                    if (!string.IsNullOrWhiteSpace(line))
+                    {
+                        _presetSentences2.Add(line.Trim());
+                    }
+                }
+                _presetSentences2 = _presetSentences2.OrderBy(x => Guid.NewGuid()).ToList();
+                Console.WriteLine($"成功从文件加载预设句子2: {_presetSentences2.Count} 条");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"加载预设句子2失败: {ex.Message}");
             }
         }
 
@@ -1833,5 +1987,148 @@ namespace ShengShengBuXi.Hubs
 
             return records;
         }
+
+        /// <summary>
+        /// 同时保存两个预设句子列表到文件
+        /// </summary>
+        private static void SavePresetSentencesToFile()
+        {
+            try
+            {
+                // 保存预设句子
+                File.WriteAllLines(_sentencesFilePath, _presetSentences);
+                Console.WriteLine($"成功保存预设句子到文件: {_presetSentences.Count} 条");
+
+                // 保存预设句子2
+                File.WriteAllLines(_sentences2FilePath, _presetSentences2);
+                Console.WriteLine($"成功保存预设句子2到文件: {_presetSentences2.Count} 条");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"保存预设句子失败: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 添加预设句子
+        /// </summary>
+        /// <param name="text">要添加的预设句子文本</param>
+        /// <returns>处理任务</returns>
+        public async Task<bool> AddPresetSentence(string text)
+        {
+            if (!_clients.TryGetValue(Context.ConnectionId, out var clientInfo))
+            {
+                _logger.LogWarning($"未注册的客户端尝试添加预设句子: {Context.ConnectionId}");
+                await Clients.Caller.SendAsync("Error", "请先注册客户端");
+                return false;
+            }
+
+            if (clientInfo.ClientType != ClientType.Monitor && clientInfo.ClientType != ClientType.WebAdmin)
+            {
+                _logger.LogWarning($"非监控或管理端客户端尝试添加预设句子: {Context.ConnectionId}, 类型: {clientInfo.ClientType}");
+                await Clients.Caller.SendAsync("Error", "只有监控或管理端客户端可以添加预设句子");
+                return false;
+            }
+
+            if (string.IsNullOrWhiteSpace(text))
+            {
+                _logger.LogWarning("尝试添加空预设句子");
+                await Clients.Caller.SendAsync("Error", "预设句子不能为空");
+                return false;
+            }
+
+            _logger.LogInformation($"添加预设句子: {text}");
+
+            try
+            {
+                // 同时添加到两个列表，确保同步
+                _presetSentences.Add(text.Trim());
+                _presetSentences2.Add(text.Trim());
+
+                // 保存到文件
+                SavePresetSentencesToFile();
+
+                // 通知其他客户端预设句子已更新
+                await Clients.Groups(new[] { "webadmin", "monitor" })
+                    .SendAsync("PresetSentencesUpdated");
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"添加预设句子失败: {ex.Message}");
+                await Clients.Caller.SendAsync("Error", $"添加预设句子失败: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 获取当前预设句子类型
+        /// </summary>
+        /// <returns>当前预设句子类型 (0: 默认, 1: 预设句子2)</returns>
+        public async Task<int> GetPresetSentenceType()
+        {
+            if (!_clients.TryGetValue(Context.ConnectionId, out var clientInfo))
+            {
+                _logger.LogWarning($"未注册的客户端尝试获取预设句子类型: {Context.ConnectionId}");
+                throw new HubException("请先注册客户端");
+            }
+
+            _logger.LogInformation($"客户端获取当前预设句子类型: {Context.ConnectionId}, 类型: {clientInfo.ClientType}");
+            return _currentPresetSentenceType;
+        }
+
+        /// <summary>
+        /// 更新预设句子类型
+        /// </summary>
+        /// <param name="type">预设句子类型 (0: 默认, 1: 预设句子2)</param>
+        /// <returns>处理任务</returns>
+        public async Task<bool> UpdatePresetSentenceType(int type)
+        {
+            if (!_clients.TryGetValue(Context.ConnectionId, out var clientInfo))
+            {
+                _logger.LogWarning($"未注册的客户端尝试更新预设句子类型: {Context.ConnectionId}");
+                await Clients.Caller.SendAsync("Error", "请先注册客户端");
+                return false;
+            }
+
+            if (clientInfo.ClientType != ClientType.Monitor && clientInfo.ClientType != ClientType.WebAdmin)
+            {
+                _logger.LogWarning($"非监控或管理端客户端尝试更新预设句子类型: {Context.ConnectionId}, 类型: {clientInfo.ClientType}");
+                await Clients.Caller.SendAsync("Error", "只有监控或管理端客户端可以更新预设句子类型");
+                return false;
+            }
+
+            if (type < 0 || type > 1)
+            {
+                _logger.LogWarning($"客户端尝试设置无效的预设句子类型: {type}");
+                await Clients.Caller.SendAsync("Error", "无效的预设句子类型，有效值为0或1");
+                return false;
+            }
+
+            _logger.LogInformation($"更新预设句子类型: {Context.ConnectionId}, 新类型: {type}");
+
+            // 更新配置
+            _currentPresetSentenceType = type;
+
+            // 保存设置
+            if (SavePresetSentenceTypeSetting())
+            {
+                _displayTextQueue.Clear();
+                // 通知其他客户端预设句子类型已更改
+                await Clients.Groups(new[] { "webadmin", "monitor" })
+                    .SendAsync("PresetSentenceTypeChanged", type);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public async Task GetClientList()
+        {
+            var clients = _clients.Values.ToList();
+            await Clients.Caller.SendAsync("ClientList", clients);
+        }
     }
 }
\ No newline at end of file
diff --git a/ShengShengBuXi/Monitor.cshtml.bak b/ShengShengBuXi/Monitor.cshtml.bak
new file mode 100644
index 0000000..5437e73
--- /dev/null
+++ b/ShengShengBuXi/Monitor.cshtml.bak
@@ -0,0 +1,2042 @@
+@page
+@model ShengShengBuXi.Pages.MonitorModel
+@{
+    ViewData["Title"] = "清竹园-中控页面";
+}
+
+<!-- 添加Bootstrap Icons库的引用 -->
+<link rel="stylesheet" href="~/css/bootstrap-icons.css">
+
+<div class="container-fluid">
+    <!-- 头部区域 (100%, 20%) -->
+    <div class="row mb-3">
+        <div class="col-12">
+            <div class="card">
+                <div class="card-body">
+                    <div class="d-flex justify-content-between align-items-center">
+                        <h2 class="my-2">
+                            清竹园-中控页面 <span id="connection-status" class="badge bg-warning">连接中...</span>
+                        </h2>
+
+                        <!-- 通话状态指示器 -->
+                        <div class="d-flex align-items-center">
+                            <div id="status-indicator" class="rounded-circle me-2"
+                                 style="width: 24px; height: 24px; background-color: red;"></div>
+                            <span id="status-text" class="me-3">未检测到通话</span>
+                        </div>
+
+                        <!-- 预设句子类型控制 -->
+                        <div class="btn-group ms-3" role="group">
+                            <span class="me-2 d-flex align-items-center">预设句子类型：</span>
+                            <input type="radio" class="btn-check" name="presetSentenceType" id="presetSentenceType0" value="0" checked onclick="updatePresetSentenceType(0)">
+                            <label class="btn btn-outline-primary" for="presetSentenceType0">默认</label>
+                            <input type="radio" class="btn-check" name="presetSentenceType" id="presetSentenceType1" value="1" onclick="updatePresetSentenceType(1)">
+                            <label class="btn btn-outline-primary" for="presetSentenceType1">预设2</label>
+                        </div>
+
+                        <!-- 控屏开关 - 优化样式 -->
+                        <div class="btn-group ms-3" role="group">
+                            <span class="me-2 d-flex align-items-center">控屏模式：</span>
+                            <input type="radio" class="btn-check" name="screenControl" id="screenControlAuto" value="0"
+                                   checked>
+                            <label class="btn btn-outline-primary" for="screenControlAuto">自动</label>
+                            <input type="radio" class="btn-check" name="screenControl" id="screenControlManual"
+                                   value="1">
+                            <label class="btn btn-outline-primary" for="screenControlManual">手动</label>
+                        </div>
+
+                        <!-- 音频传输开关 - 隐藏 -->
+                        <div class="btn-group ms-3" role="group" style="display: none;">
+                            <input type="radio" class="btn-check" name="audioStreaming" id="audioStreaming1" value="1"
+                                   checked>
+                            <label class="btn btn-outline-success" for="audioStreaming1">开启音频传输</label>
+
+                            <input type="radio" class="btn-check" name="audioStreaming" id="audioStreaming0" value="0"
+                                   style="display: none;">
+                            <label class="btn btn-outline-danger" for="audioStreaming0"
+                                   style="display: none;">关闭音频传输</label>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 主体区域 (20%+60%+20%, 80%) -->
+        <div class="row">
+            <!-- 左侧文字列表 (20%, 80%) -->
+            <div class="col-3">
+                <div class="card h-100">
+                    <div class="card-header">
+                        <h5 class="mb-0">语音列表</h5>
+                    </div>
+                    <div class="card-body p-0">
+                        <div id="monitor-text-list" class="list-group list-group-flush"
+                             style="max-height: 75vh; overflow-y: auto;">
+                            <!-- 文本列表内容将通过JS动态填充 -->
+                            <div class="text-center text-muted p-3">加载中...</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 中间区域 (60%, 80%) -->
+            <div class="col-6">
+                <div class="card h-100">
+                    <div class="card-header d-flex justify-content-between align-items-center">
+                        <div>
+                            <button class="btn btn-sm btn-outline-primary me-2" onclick="copyDisplayedText()">
+                                <i class="bi bi-clipboard"></i> 复制文本
+                            </button>
+                        </div>
+                        <button class="btn btn-sm btn-outline-secondary" onclick="closeTextDisplay()">关闭</button>
+                    </div>
+                    <div class="card-body">
+                        <div id="content-area" style="height: 75vh;">
+                            <!-- 文本显示区域 -->
+                            <div id="text-display-area" class="mb-4" style="display: none; height: 20%;">
+                                <div class="card">
+                                    <div class="card-body">
+                                        <p id="displayed-text" class="mb-0"></p>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- 文本输入区域 -->
+                            <div id="input-text-area" style="height: 40%;">
+                                <div class="card h-100">
+                                    <div class="card-header">
+                                        <h5 class="mb-0">
+                                            文本编辑
+                                        </h5>
+                                    </div>
+                                    <div class="card-body">
+                                        <textarea id="text-input" class="form-control h-100" placeholder="请输入要显示的文本..."></textarea>
+
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- 按钮组区域 - 隐藏添加并移除按钮 -->
+                            <div id="action-buttons-area" class="mt-3" style="height: 20%;">
+                                <div class="card h-100">
+                                    <div class="card-body d-flex justify-content-center align-items-center">
+                                        <button id="add-text-btn" class="btn btn-primary me-3" data-bs-toggle="tooltip"
+                                                title="将文本添加到显示队列，并显示在大屏上" onclick="addDisplayText()">
+                                            <i class="bi bi-plus-circle"></i> 显示到大屏
+                                        </button>
+                                        <button id="add-and-remove-btn" class="btn btn-warning" data-bs-toggle="tooltip"
+                                                title="将文本添加到显示队列，并从监控列表中移除当前选中项" onclick="addDisplayTextAndRemoveMonitor()"
+                                                style="display: none;">
+                                            <i class="bi bi-arrow-right-circle"></i> 添加并移除
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- 其他中间内容 -->
+                            <div id="other-content">
+                                <!-- 中间的空div -->
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 右侧文字列表 (20%, 80%) -->
+            <div class="col-3">
+                <div class="card h-100">
+                    <div class="card-header">
+                        <h5 class="mb-0">显示文本列表</h5>
+                    </div>
+                    <div class="card-body p-0">
+                        <div id="display-text-list" class="list-group list-group-flush"
+                             style="max-height: 75vh; overflow-y: auto;">
+                            <!-- 文本列表内容将通过JS动态填充 -->
+                            <div class="text-center text-muted p-3">加载中...</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 预设句子控制区域 -->
+        <div class="row mt-3">
+            <div class="col-12">
+                <div class="card">
+                    <div class="card-header">
+                        <h5 class="mb-0">预设句子控制</h5>
+                    </div>
+                    <div class="card-body">
+                        <div class="row">
+                            <div class="col-md-12">
+                                <div class="form-group">
+                                    <label class="form-label">添加预设句子</label>
+                                    <div class="input-group">
+                                        <input type="text" class="form-control" id="presetSentenceInput" placeholder="输入预设句子...">
+                                        <button class="btn btn-primary" onclick="addPresetSentence()">添加</button>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 调试区域 (底部) -->
+        <div class="row mt-3">
+            <div class="col-12">
+                <div class="card">
+                    <div class="card-header d-flex justify-content-between align-items-center">
+                        <span>调试信息</span>
+                        <div>
+                            <button class="btn btn-sm btn-outline-danger me-2" onclick="clearDebug()">清空</button>
+                            <button class="btn btn-sm btn-outline-secondary" onclick="toggleDebug()">隐藏</button>
+                        </div>
+                    </div>
+                    <div class="card-body">
+                        <pre id="debug-log" style="max-height: 150px; overflow-y: auto;"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 消息区域 -->
+    <div id="message-area" class="position-fixed bottom-0 end-0 p-3" style="z-index: 1050;"></div>
+
+    <!-- 来电确认对话框 -->
+    <div class="modal fade" id="callConfirmDialog" tabindex="-1" aria-labelledby="callConfirmDialogLabel"
+         aria-hidden="true" data-bs-backdrop="static" data-bs-keyboard="false">
+        <div class="modal-dialog modal-dialog-centered">
+            <div class="modal-content">
+                <div class="modal-header bg-primary text-white">
+                    <h5 class="modal-title" id="callConfirmDialogLabel">
+                        <i class="bi bi-telephone-inbound"></i> 来电提醒
+                    </h5>
+                </div>
+                <div class="modal-body text-center py-4">
+                    <div class="mb-3">
+                        <i class="bi bi-telephone-fill text-primary" style="font-size: 3rem;"></i>
+                    </div>
+                    <h5>检测到新的通话</h5>
+                    <p class="text-muted">请点击接听开始播放音频</p>
+                </div>
+                <div class="modal-footer justify-content-center">
+                    <button type="button" class="btn btn-primary" onclick="confirmCall()">
+                        <i class="bi bi-telephone"></i> 接听
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    @section Scripts {
+        <script src="~/lib/microsoft-signalr/signalr.min.js"></script>
+
+        <script src="https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js"></script>
+        <script src='https://web.sdk.qcloud.com/trtc/webrtc/v5/dist/trtc.js'></script>
+        <script src="~/js/lib-generate-test-usersig.min.js"></script>
+        <script src="~/js/generateTestUserSig.js"></script>
+        <script>
+            let connection = null;
+            let refreshDisplayInterval = null;
+            let callInProgress = false;
+            let isActiveShow = false;
+            // 当前播放的音频元素和按钮引用
+            let currentAudio = null;
+            let currentPlayButton = null;
+
+            // 控屏开关状态
+            let isManualScreenControl = false;
+
+            // 实时音频相关变量
+            let audioContext = null;
+            let audioStreamSource = null;
+            let isAudioStreamEnabled = false;
+            let audioGainNode = null;
+            let currentVolume = 1.0; // 默认音量
+            let volumeBoost = 3.0; // 音量增益倍数，提高接收到的音频音量
+
+            const sdkAppId = 1600079538;
+            const sdkSecretKey = "df2427757c0ec29ae8ca45611ddb70381144d55338e5ac73c2da27a9c32729f6";
+            let userId = "监听者：" + Math.random().toString(36).substring(2, 10);
+            let roomId = 8888;
+
+            let trtc = TRTC.create();
+
+            async function enterRoom() {
+                try {
+                    trtc = TRTC.create();
+                    // 生成用户签名
+                    const { userSig } = genTestUserSig({ sdkAppId, userId, sdkSecretKey });
+                    // 进入房间
+                    await trtc.enterRoom({ sdkAppId, userId, userSig, roomId: roomId });
+                } catch (error) {
+
+                }
+            }
+
+
+            async function leaveRoom() {
+                try {
+                    await trtc.exitRoom();
+                    trtc.destroy();
+                    // 更新状态指示器为红色（已断开）
+                } catch (error) {
+
+                }
+            }
+
+            // 调试日志
+            function log(message) {
+                const timestamp = new Date().toLocaleTimeString();
+                const logMsg = `[${timestamp}] ${message}`;
+                console.log(logMsg);
+                const logElem = document.getElementById("debug-log");
+                if (logElem) {
+                    const logLine = document.createElement("div");
+                    logLine.textContent = logMsg;
+                    logElem.insertBefore(logLine, logElem.firstChild);
+                }
+            }
+
+            // 显示/隐藏调试区域
+            function toggleDebug() {
+                const debugCard = document.querySelector("#debug-log").closest(".card");
+                const isVisible = debugCard.style.display !== "none";
+                debugCard.style.display = isVisible ? "none" : "";
+            }
+
+            // 清空调试日志
+            function clearDebug() {
+                document.getElementById("debug-log").innerHTML = "";
+            }
+
+            // 显示消息提示
+            function showMessage(message, type = 'info', duration = 5000) {
+                const messageArea = document.getElementById("message-area");
+                const alert = document.createElement("div");
+                alert.className = `alert alert-${type} alert-dismissible fade show`;
+                alert.innerHTML = `
+                                                                ${message}
+                                                                <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+                                                            `;
+                messageArea.appendChild(alert);
+
+                // 自动移除
+                setTimeout(() => {
+                    alert.classList.remove('show');
+                    setTimeout(() => alert.remove(), 150);
+                }, duration);
+            }
+
+            // 更新连接状态
+            function updateConnectionStatus(status, type = 'warning') {
+                const statusElem = document.getElementById("connection-status");
+                statusElem.className = `badge bg-${type}`;
+                statusElem.textContent = status;
+            }
+
+            // 初始化SignalR连接
+            function initSignalR() {
+                log("初始化SignalR连接...");
+                updateConnectionStatus("连接中...", "warning");
+
+                // 创建连接
+                connection = new signalR.HubConnectionBuilder()
+                    .withUrl("/audiohub")
+                    .configureLogging(signalR.LogLevel.Debug)
+                    .withAutomaticReconnect()
+                    .build();
+
+                // 注册连接事件处理程序
+                connection.onreconnecting(error => {
+                    log("重新连接中: " + (error ? error.message : "未知错误"));
+                    updateConnectionStatus("重连中...", "warning");
+                });
+
+                connection.onreconnected(connectionId => {
+                    log("已重新连接，ID: " + connectionId);
+                    updateConnectionStatus("已连接", "success");
+                    // 重新注册
+                    registerAsMonitor();
+                });
+
+                connection.onclose(error => {
+                    log("连接已关闭: " + (error ? error.message : ""));
+                    updateConnectionStatus("已断开", "danger");
+                    // 5秒后重连
+                    setTimeout(() => startConnection(), 5000);
+                });
+
+                // 注册服务器消息处理程序
+                setupSignalRHandlers();
+
+                // 建立连接
+                startConnection();
+            }
+
+            // 开始连接
+            function startConnection() {
+                log("正在连接到服务器...");
+
+                connection.start()
+                    .then(() => {
+                        log("已连接到服务器，连接ID: " + connection.connectionId);
+                        updateConnectionStatus("已连接", "success");
+                        registerAsMonitor();
+                    })
+                    .catch(err => {
+                        log("连接失败: " + err);
+                        updateConnectionStatus("连接失败", "danger");
+                        setTimeout(() => startConnection(), 5000);
+                    });
+            }
+
+            // 注册为中控客户端
+            function registerAsMonitor() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法注册：未连接");
+                    return;
+                }
+
+                log("正在注册为中控客户端...");
+
+                connection.invoke("RegisterClient", 2, "中控监视页面")
+                    .then(() => {
+                        log("已注册为中控客户端");
+                        // 加载初始数据
+                        loadMonitorTextList();
+                        loadDisplayTextList();
+
+                        // 获取当前显示模式
+                        getServerDisplayType();
+
+                        // 获取当前音频流设置
+                        getServerAudioStreamingSetting();
+
+                        // 获取当前控屏设置
+                        getServerScreenControlSetting();
+
+                         // 获取当前预设句子类型设置
+                    getServerPresetSentenceTypeSetting();
+
+                        // 设置定时刷新显示列表
+                        if (refreshDisplayInterval) {
+                            clearInterval(refreshDisplayInterval);
+                        }
+                        refreshDisplayInterval = setInterval(loadDisplayTextList, 10000);  // 每10秒刷新一次
+                    })
+                    .catch(err => {
+                        log("注册失败: " + err);
+                        showMessage("注册失败: " + err, "danger");
+                    });
+            }
+
+            // 设置SignalR事件处理程序
+            function setupSignalRHandlers() {
+                // 注册确认
+                connection.on("RegistrationConfirmed", (clientId) => {
+                    log("注册确认，客户端ID: " + clientId);
+                    showMessage("已注册为中控客户端", "success");
+                });
+
+                // 注册失败
+                connection.on("RegistrationFailed", (reason) => {
+                    log("注册失败: " + reason);
+                    showMessage("注册失败: " + reason, "danger");
+                });
+
+                // 通话状态改变
+                connection.on("CallStateChanged", (isActive) => {
+                    updateCallStatus(isActive);
+                });
+
+                // 错误消息
+                connection.on("Error", (message) => {
+                    log("错误: " + message);
+                    showMessage("错误: " + message, "danger");
+                });
+
+                // 接收实时语音识别结果
+                connection.on("ReceiveSpeechToTextResult", (result) => {
+                    log(`接收到实时语音识别结果: ${result.substring(0, 30)}${result.length > 30 ? '...' : ''}`);
+
+                    // 使用防抖动技术显示实时识别结果，避免频繁更新导致页面卡顿
+                    if (window.realtimeTextDebounceTimer) {
+                        clearTimeout(window.realtimeTextDebounceTimer);
+                    }
+                    window.realtimeTextDebounceTimer = setTimeout(() => {
+                        showRealtimeTextResult(result);
+                    }, 300); // 300毫秒的防抖动延迟
+                });
+
+                // 接收最终语音识别结果
+                connection.on("ReceiveSpeechToEndTextResult", (result) => {
+                    log(`接收到最终语音识别结果: ${result.substring(0, 30)}${result.length > 30 ? '...' : ''}`);
+
+                    // 清除任何正在进行的实时文本更新定时器
+                    if (window.realtimeTextDebounceTimer) {
+                        clearTimeout(window.realtimeTextDebounceTimer);
+                    }
+
+                    // 显示最终识别结果
+                    showFinalTextResult(result);
+
+                    // 同时添加到监控列表的顶部（如果不存在于列表中）
+                    addToMonitorList(result);
+                });
+
+                // 显示模式更新消息
+                connection.on("DisplayTypeChanged", (displayType) => {
+                    log(`服务器显示模式已更改为: ${displayType}`);
+                    updateDisplayModeUI(displayType);
+                });
+
+                // 显示模式更新结果
+                connection.on("DisplayTypeUpdated", (success, message) => {
+                    if (success) {
+                        log(`显示模式更新成功: ${message}`);
+                        showMessage(message, "success");
+                    } else {
+                        log(`显示模式更新失败: ${message}`);
+                        showMessage(message, "danger");
+                    }
+                });
+
+                // 接收实时音频数据
+                connection.on("ReceiveAudioData", (audioData) => {
+                    if (!isActiveShow) {
+                        // 添加音频流持续检测逻辑
+                        if (!window.audioStreamStartTime) {
+                            // 设置音频流开始接收时间
+                            window.audioStreamStartTime = Date.now();
+                            log("检测到音频流，开始计时");
+                        } else {
+                            // 检查是否超过5秒
+                            const elapsedTime = Date.now() - window.audioStreamStartTime;
+                            if (elapsedTime > 5000) {
+                                log(`音频流持续时间 ${(elapsedTime/1000).toFixed(1)}秒，触发通话状态更新`);
+                                window.audioStreamStartTime = null; // 重置计时器
+                                updateCallStatus(true);
+                            }
+                        }
+                        return;
+                    } else {
+                        // 重置音频流计时器
+                        window.audioStreamStartTime = null;
+                    }
+                });
+
+                // 音频流设置更新消息
+                connection.on("AudioStreamingChanged", (enabled) => {
+                    log(`服务器音频流设置已更改为: ${enabled ? "开启" : "关闭"}`);
+                    updateAudioStreamingUI(enabled);
+                });
+
+                // 音频流设置更新结果
+                connection.on("AudioStreamingUpdated", (success, message) => {
+                    if (success) {
+                        log(`音频流设置更新成功: ${message}`);
+                        showMessage(message, "success");
+                    } else {
+                        log(`音频流设置更新失败: ${message}`);
+                        showMessage(message, "danger");
+                    }
+                });
+
+                // 控屏设置更新消息
+                connection.on("ScreenControlSettingChanged", (isManual) => {
+                    log(`服务器控屏设置已更改为: ${isManual ? "手动" : "自动"}`);
+                    updateScreenControlUI(isManual);
+                });
+
+                // 控屏设置更新结果
+                connection.on("ScreenControlSettingUpdated", (success, message) => {
+                    if (success) {
+                        log(`控屏设置更新成功: ${message}`);
+                        showMessage(message, "success");
+                    } else {
+                        log(`控屏设置更新失败: ${message}`);
+                        showMessage(message, "danger");
+                    }
+                });
+            }
+
+            // 更新通话状态
+            function updateCallStatus(isActive) {
+                isActiveShow = isActive;
+                if (isActive) {
+                    // 当检测到新通话时，先显示确认对话框
+                    const confirmDialog = new bootstrap.Modal(document.getElementById('callConfirmDialog'));
+                    confirmDialog.show();
+                    enterRoom();
+                    return; // 等待用户确认后再继续处理
+                } else {
+                    const indicator = document.getElementById("status-indicator");
+                    const statusText = document.getElementById("status-text");
+                    indicator.style.backgroundColor = "red";
+                    statusText.textContent = "未检测到通话";
+
+                    // 如果确认对话框还在显示（用户未点击接听），则自动关闭
+                    const confirmDialog = bootstrap.Modal.getInstance(document.getElementById('callConfirmDialog'));
+                    if (confirmDialog) {
+                        confirmDialog.hide();
+                        exitRoom();
+                        log("通话已结束，自动关闭确认对话框");
+                    }
+                }
+
+                // 有新通话时刷新监控列表
+                loadMonitorTextList();
+            }
+
+            // 用户确认接听通话
+            function confirmCall() {
+                const indicator = document.getElementById("status-indicator");
+                const statusText = document.getElementById("status-text");
+                indicator.style.backgroundColor = "green";
+                statusText.textContent = "正在通话中";
+                callInProgress = true;
+
+                // 初始化音频上下文（如果需要且启用了音频流）
+                if (isAudioStreamEnabled) {
+                    // 如果存在音频上下文，则先尝试关闭，然后重新创建
+                    if (audioContext) {
+                        log("重置音频上下文以确保新的通话正常播放");
+                        try {
+                            // 释放旧的增益节点
+                            if (audioGainNode) {
+                                audioGainNode.disconnect();
+                                audioGainNode = null;
+                            }
+                            // 关闭旧的音频上下文
+                            audioContext.close().catch(e => log("关闭音频上下文失败: " + e));
+                            audioContext = null;
+                        } catch (e) {
+                            log("重置音频上下文失败: " + e);
+                        }
+                    }
+
+                    // 创建新的音频上下文
+                    initAudioContext();
+                }
+
+                // 关闭确认对话框
+                const confirmDialog = bootstrap.Modal.getInstance(document.getElementById('callConfirmDialog'));
+                if (confirmDialog) {
+                    confirmDialog.hide();
+                }
+
+                // 刷新监控列表
+                loadMonitorTextList();
+            }
+
+            // 加载监控文本列表
+            function loadMonitorTextList() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法加载监控文本列表：未连接");
+                    return;
+                }
+
+                log("加载监控文本列表...");
+
+                connection.invoke("GetMonitorTextList")
+                    .then(data => {
+                        log(`获取到${data.length}条监控文本`);
+                        renderMonitorTextList(data);
+                    })
+                    .catch(err => {
+                        log("获取监控文本列表失败: " + err);
+                        showMessage("获取监控文本列表失败", "danger");
+                    });
+            }
+
+            // 渲染监控文本列表
+            function renderMonitorTextList(data) {
+                const container = document.getElementById("monitor-text-list");
+                container.innerHTML = ""; // 清空现有内容
+
+                if (!data || data.length === 0) {
+                    container.innerHTML = '<div class="text-center text-muted p-3">暂无监控文本</div>';
+                    return;
+                }
+
+                // 按时间倒序排列
+                data.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+                // 渲染每一项
+                data.forEach(item => {
+                    const listItem = document.createElement("div");
+                    listItem.className = "list-group-item";
+                    listItem.dataset.id = item.id;
+                    // 存储原始文本，用于点击后显示
+                    listItem.dataset.fullText = item.text || item.completedText || "无文本内容";
+
+                    // 添加点击事件
+                    listItem.addEventListener('click', function (e) {
+                        // 如果点击的是按钮，不触发选择
+                        if (e.target.tagName === 'BUTTON' || e.target.tagName === 'I' ||
+                            e.target.closest('button')) {
+                            return;
+                        }
+
+                        // 移除其他项的active类
+                        document.querySelectorAll("#monitor-text-list .list-group-item").forEach(item => {
+                            item.classList.remove("active");
+                        });
+
+                        // 添加active类到当前项
+                        this.classList.add("active");
+
+                        // 显示文本
+                        displayTextInCenter(this.dataset.fullText);
+                    });
+
+                    // 转换日期格式
+                    const date = new Date(item.timestamp);
+                    const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
+
+                    const text = item.text || item.completedText || "无文本内容";
+                    // 截取前10个字符，若不足10个则全部显示
+                    const shortText = text.length > 10 ? text.substring(0, 10) : text;
+
+                    listItem.innerHTML = `
+                                                                            <div class="d-flex justify-content-between align-items-start mb-1">
+                                                                                <small class="text-muted">【${shortText}】</small>
+                                                                                <div class="btn-group btn-group-sm">
+                                                                                    <button class="btn btn-outline-primary btn-sm" onclick="playAudio('${item.recordingPath || ''}', this)">
+                                                                                        <i class="bi bi-play-fill"></i>
+                                                                                    </button>
+                                                                                    <button class="btn btn-outline-secondary btn-sm" onclick="downloadRecording('${item.recordingPath || ''}')">
+                                                                                        <i class="bi bi-download"></i>
+                                                                                    </button>
+                                                                                    <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${item.id}')">
+                                                                                        <i class="bi bi-trash"></i>
+                                                                                    </button>
+                                                                                </div>
+                                                                            </div>
+                                                                            <div>${formattedDate}</div>
+                                                                        `;
+
+                    container.appendChild(listItem);
+                });
+            }
+
+            // 删除监控文本
+            function deleteMonitorText(id) {
+                if (!id || !connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法删除监控文本：未连接或ID无效");
+                    return;
+                }
+
+                log(`正在删除监控文本: ${id}`);
+
+                connection.invoke("DelMonitorText", id)
+                    .then(result => {
+                        log(`删除监控文本${result ? '成功' : '失败'}`);
+                        if (result) {
+                            // 从UI中移除该项
+                            const item = document.querySelector(`#monitor-text-list .list-group-item[data-id="${id}"]`);
+                            if (item) {
+                                item.remove();
+                            }
+                            showMessage("已删除文本", "success");
+                        } else {
+                            showMessage("删除文本失败", "warning");
+                        }
+                    })
+                    .catch(err => {
+                        log("删除监控文本失败: " + err);
+                        showMessage("删除监控文本失败: " + err, "danger");
+                    });
+            }
+
+            // 播放或暂停音频
+            function playAudio(path, buttonElement) {
+                // 获取按钮元素
+                const button = buttonElement || event.currentTarget;
+                const buttonIcon = button.querySelector('i');
+
+                // 如果没有路径
+                if (!path) {
+                    showMessage("无可播放的录音", "warning");
+                    return;
+                }
+
+                // 如果是当前正在播放的音频
+                if (currentAudio && currentPlayButton === button) {
+                    if (currentAudio.paused) {
+                        // 如果当前是暂停状态，则继续播放
+                        log(`继续播放音频: ${path}`);
+                        currentAudio.play()
+                            .then(() => {
+                                // 更改按钮图标为暂停
+                                buttonIcon.className = "bi bi-pause-fill";
+                                showMessage("继续播放音频", "info");
+                            })
+                            .catch(err => {
+                                showMessage(`播放失败: ${err}`, "danger");
+                                log(`继续播放失败: ${err}`);
+                            });
+                    } else {
+                        // 如果当前是播放状态，则暂停
+                        log(`暂停播放音频: ${path}`);
+                        currentAudio.pause();
+                        // 更改按钮图标为播放
+                        buttonIcon.className = "bi bi-play-fill";
+                        showMessage("已暂停播放", "info");
+                    }
+                    return;
+                }
+
+                // 如果有其他正在播放的音频，先停止它
+                if (currentAudio) {
+                    currentAudio.pause();
+                    // 恢复之前的播放按钮图标
+                    if (currentPlayButton && currentPlayButton.querySelector('i')) {
+                        currentPlayButton.querySelector('i').className = "bi bi-play-fill";
+                    }
+                }
+
+                log(`播放音频: ${path}`);
+
+                // 创建新的音频元素
+                const audioElement = new Audio(path);
+
+                // 应用当前音量设置
+                audioElement.volume = currentVolume;
+
+                // 设置当前播放的音频和按钮
+                currentAudio = audioElement;
+                currentPlayButton = button;
+
+                // 添加事件处理
+                audioElement.addEventListener('error', () => {
+                    showMessage("无法播放音频文件，可能不存在或格式不支持", "warning");
+                    log(`音频播放失败: ${path}`);
+                    // 重置当前播放状态
+                    currentAudio = null;
+                    currentPlayButton = null;
+                    buttonIcon.className = "bi bi-play-fill";
+                });
+
+                audioElement.addEventListener('loadeddata', () => {
+                    log(`音频已加载，开始播放: ${path}, 音量: ${currentVolume * 100}%`);
+                });
+
+                audioElement.addEventListener('ended', () => {
+                    log(`音频播放结束: ${path}`);
+                    // 重置按钮状态
+                    buttonIcon.className = "bi bi-play-fill";
+                    // 重置当前播放状态
+                    currentAudio = null;
+                    currentPlayButton = null;
+                });
+
+                // 播放音频
+                audioElement.play()
+                    .then(() => {
+                        // 更改按钮图标为暂停
+                        buttonIcon.className = "bi bi-pause-fill";
+                        showMessage("正在播放音频", "info");
+                    })
+                    .catch(err => {
+                        showMessage(`播放失败: ${err}`, "danger");
+                        log(`播放失败: ${err}`);
+                        // 重置当前播放状态
+                        currentAudio = null;
+                        currentPlayButton = null;
+                    });
+            }
+
+            // 下载录音
+            function downloadRecording(path) {
+                if (!path) {
+                    showMessage("无可下载的录音", "warning");
+                    return;
+                }
+
+                log(`下载录音: ${path}`);
+
+                // 创建一个链接元素用于下载
+                const a = document.createElement('a');
+                a.href = path;
+                a.download = path.split('/').pop(); // 从路径中提取文件名
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+
+                showMessage("正在下载录音文件", "info");
+            }
+
+            // 加载显示文本列表
+            function loadDisplayTextList() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法加载显示文本列表：未连接");
+                    return;
+                }
+
+                log("加载显示文本列表...");
+
+                connection.invoke("GetDisplayList")
+                    .then(data => {
+                        log(`获取到${data.length}条显示文本`);
+                        renderDisplayTextList(data);
+                    })
+                    .catch(err => {
+                        log("获取显示文本列表失败: " + err);
+                    });
+            }
+
+            // 渲染显示文本列表
+            function renderDisplayTextList(data) {
+                const container = document.getElementById("display-text-list");
+                container.innerHTML = ""; // 清空现有内容
+
+                if (!data || data.length === 0) {
+                    container.innerHTML = '<div class="text-center text-muted p-3">暂无显示文本</div>';
+                    return;
+                }
+
+                // 按时间倒序排列
+                data.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+                // 渲染每一项
+                data.forEach(item => {
+                    const listItem = document.createElement("div");
+                    listItem.className = "list-group-item";
+                    // 存储原始文本，用于点击后显示
+                    listItem.dataset.fullText = item.text || item.completedText || "无文本内容";
+
+                    // 添加点击事件
+                    listItem.addEventListener('click', function () {
+                        onlyDisplayTextInCenter(this.dataset.fullText);
+                    });
+
+                    // 转换日期格式
+                    const date = new Date(item.timestamp);
+                    const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
+
+                    const text = item.text || item.completedText || "无文本内容";
+                    // 截取前5个字符，若不足5个则全部显示
+                    const shortText = text.length > 5 ? text.substring(0, 5) : text;
+
+                    listItem.innerHTML = `
+                                                                            <div class="mb-1">
+                                                                                <small class="text-muted">${formattedDate}</small>
+                                                                            </div>
+                                                                            <div>【${shortText}】</div>
+                                                                        `;
+
+                    container.appendChild(listItem);
+                });
+            }
+
+            // 监听显示模式单选按钮的变化
+            function setupDisplayModeListeners() {
+                const displayModeButtons = document.querySelectorAll('input[name="displayMode"]');
+                displayModeButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const mode = parseInt(this.value);
+                        log(`显示模式已切换为: ${mode === 0 ? "识别立即显示" : "手动显示"}`);
+
+                        // 调用服务器端方法更新显示模式
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateDisplayType", mode)
+                                .then(() => {
+                                    showMessage(`已切换为${mode === 0 ? "识别立即显示" : "手动显示"}模式`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新显示模式失败: ${err}`);
+                                    showMessage("切换显示模式失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentMode = mode === 0 ? 1 : 0;
+                                    document.getElementById(`displayMode${currentMode}`).checked = true;
+                                });
+                        } else {
+                            log("无法更新显示模式：未连接到服务器");
+                            showMessage("无法更新显示模式：未连接到服务器", "warning");
+                        }
+                    });
+                });
+
+                // 监听音频传输单选按钮的变化
+                const audioStreamingButtons = document.querySelectorAll('input[name="audioStreaming"]');
+                audioStreamingButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const enabled = parseInt(this.value) === 1;
+                        log(`音频传输已切换为: ${enabled ? "开启" : "关闭"}`);
+
+                        // 设置本地音频流状态
+                        isAudioStreamEnabled = enabled;
+
+                        // 如果开启了音频流，初始化音频上下文
+                        if (enabled && callInProgress) {
+                            initAudioContext();
+                        }
+
+                        // 调用服务器端方法更新音频流设置
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateAudioStreaming", enabled)
+                                .then(() => {
+                                    showMessage(`已${enabled ? "开启" : "关闭"}音频传输`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新音频流设置失败: ${err}`);
+                                    showMessage("切换音频传输失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentValue = enabled ? 0 : 1;
+                                    document.getElementById(`audioStreaming${currentValue}`).checked = true;
+                                    isAudioStreamEnabled = !enabled;
+                                });
+                        } else {
+                            log("无法更新音频流设置：未连接到服务器");
+                            showMessage("无法更新音频流设置：未连接到服务器", "warning");
+                        }
+                    });
+                });
+            }
+
+            // 设置音频流开关监听器
+            function setupAudioStreamingListeners() {
+                const audioStreamingButtons = document.querySelectorAll('input[name="audioStreaming"]');
+                audioStreamingButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const enabled = parseInt(this.value) === 1;
+                        isAudioStreamEnabled = enabled;
+                        log(`音频流已切换为: ${enabled ? "开启" : "关闭"}`);
+
+                        // 如果开启了音频流，初始化音频上下文
+                        if (enabled && callInProgress) {
+                            initAudioContext();
+                        }
+
+                        // 调用服务器端方法更新音频流设置
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateAudioStreaming", enabled)
+                                .then(() => {
+                                    showMessage(`已${enabled ? "开启" : "关闭"}音频传输`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新音频流设置失败: ${err}`);
+                                    showMessage("切换音频传输失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentValue = enabled ? 0 : 1;
+                                    document.getElementById(`audioStreaming${currentValue}`).checked = true;
+                                    isAudioStreamEnabled = !enabled;
+                                });
+                        } else {
+                            log("无法更新音频流设置：未连接到服务器");
+                            showMessage("无法更新音频流设置：未连接到服务器", "warning");
+                        }
+                    });
+                });
+            }
+
+            // 设置控屏开关监听器
+            function setupScreenControlListeners() {
+                console.log('aaaa')
+                const screenControlButtons = document.querySelectorAll('input[name="screenControl"]');
+                screenControlButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const isManual = parseInt(this.value) === 1;
+                        isManualScreenControl = isManual;
+                        log(`控屏模式已切换为: ${isManual ? "手动" : "自动"}`);
+
+                        // 调用服务器端方法更新控屏设置
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateScreenControlSetting", isManual)
+                                .then(() => {
+                                    showMessage(`已切换为${isManual ? "手动" : "自动"}控屏模式`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新控屏设置失败: ${err}`);
+                                    showMessage("切换控屏模式失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentValue = isManual ? 0 : 1;
+                                    document.getElementById(`screenControl${currentValue === 0 ? 'Auto' : 'Manual'}`).checked = true;
+                                });
+                        }
+                    });
+                });
+            }
+
+            // 设置音量控制监听器
+            function setupVolumeControlListener() {
+                const volumeControl = document.getElementById('volumeControl');
+                if (volumeControl) {
+                    volumeControl.addEventListener('input', function (e) {
+                        currentVolume = parseFloat(e.target.value);
+                        log(`音量已调整为: ${currentVolume * 100}%`);
+
+                        // 如果已经创建了增益节点，立即应用音量设置
+                        if (audioGainNode) {
+                            audioGainNode.gain.value = currentVolume;
+                        }
+
+                        // 同时调整已播放的录音音量
+                        if (currentAudio) {
+                            currentAudio.volume = currentVolume;
+                        }
+                    });
+                }
+            }
+
+            // 初始化页面
+            document.addEventListener('DOMContentLoaded', function () {
+
+                // 初始化音频上下文
+                initAudioContext();
+
+                // 初始化SignalR连接
+                initSignalR();
+
+                // 设置各种事件监听器
+                // setupEventListeners();
+                setupDisplayModeListeners();
+                setupAudioStreamingListeners();
+                setupScreenControlListeners();
+
+                // 初始化音量控制
+                setupVolumeControl();
+
+                // 注册为监控端
+                registerAsMonitor();
+
+                // 初始化工具提示
+                setTimeout(initTooltips, 1000);
+
+                // 默认开启音频传输
+                document.getElementById("audioStreaming1").checked = true;
+                isAudioStreamEnabled = true;
+
+                // 初始化UI和事件
+                initUI();
+
+
+            });
+
+            // 页面卸载前清理资源
+            window.addEventListener('beforeunload', function () {
+                if (refreshDisplayInterval) {
+                    clearInterval(refreshDisplayInterval);
+                }
+
+                // 关闭音频上下文
+                if (audioContext) {
+                    audioContext.close().catch(e => console.log("关闭音频上下文失败: " + e));
+                    audioContext = null;
+                }
+            });
+
+            // 更新显示模式UI
+            function updateDisplayModeUI(displayType) {
+                // 将displayType转换为整数确保类型匹配
+                displayType = parseInt(displayType);
+
+                // 确保值在有效范围内(0或1)
+                if (displayType === 0 || displayType === 1) {
+                    // 更新单选按钮状态
+                    document.getElementById(`displayMode${displayType}`).checked = true;
+
+                    log(`UI显示模式已更新为: ${displayType === 0 ? "识别立即显示" : "手动显示"}`);
+                }
+            }
+
+            // 获取服务器当前的显示模式
+            function getServerDisplayType() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取显示模式：未连接");
+                    return;
+                }
+
+                log("获取服务器当前显示模式...");
+
+                connection.invoke("GetDisplayType")
+                    .then(displayType => {
+                        log(`获取到服务器当前显示模式: ${displayType}`);
+                        updateDisplayModeUI(displayType);
+                    })
+                    .catch(err => {
+                        log("获取显示模式失败: " + err);
+                    });
+            }
+
+            // 在中间区域显示文本（用于左侧列表，包含编辑功能）
+            function displayTextInCenter(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.textContent = text;
+
+                // 同时将文本填入输入框
+               // document.getElementById("text-input").value = text;
+
+                // 显示文本编辑区域和按钮区域
+                document.getElementById("input-text-area").style.display = "block";
+                document.getElementById("action-buttons-area").style.display = "block";
+
+                log("在中间区域显示文本（带编辑功能）");
+            }
+
+            // 在中间区域只显示文本（用于右侧列表，不包含编辑功能）
+            function onlyDisplayTextInCenter(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.textContent = text;
+
+                // 隐藏文本编辑区域和按钮区域
+                document.getElementById("input-text-area").style.display = "none";
+                document.getElementById("action-buttons-area").style.display = "none";
+
+                log("在中间区域只显示文本（无编辑功能）");
+            }
+
+            // 关闭文本显示
+            function closeTextDisplay() {
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "none";
+
+                // 重新显示编辑区域和按钮区域
+                document.getElementById("input-text-area").style.display = "block";
+                document.getElementById("action-buttons-area").style.display = "block";
+
+                log("关闭文本显示");
+            }
+
+            // 复制显示的文本
+            function copyDisplayedText() {
+                const textArea = document.getElementById("displayed-text");
+                const text = textArea.textContent;
+
+                if (!text || text.trim() === "") {
+                    showMessage("请先从左侧列表选择一条文本记录", "warning");
+                    log("尝试复制文本失败：未选择文本");
+                    return;
+                }
+
+                // 创建临时textarea元素用于复制
+                const tempTextArea = document.createElement("textarea");
+                tempTextArea.value = text;
+                document.body.appendChild(tempTextArea);
+                tempTextArea.select();
+
+                try {
+                    // 尝试复制到剪贴板
+                    const success = document.execCommand("copy");
+                    if (success) {
+                        showMessage("文本已复制到剪贴板", "success");
+                        log("文本已复制到剪贴板");
+                    } else {
+                        showMessage("复制失败，请手动复制", "warning");
+                        log("复制文本失败：execCommand返回false");
+                    }
+                } catch (err) {
+                    showMessage("复制失败: " + err, "danger");
+                    log("复制文本失败: " + err);
+                }
+
+                // 移除临时元素
+                document.body.removeChild(tempTextArea);
+            }
+
+            // 初始化工具提示
+            function initTooltips() {
+                var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+                tooltipTriggerList.map(function (tooltipTriggerEl) {
+                    return new bootstrap.Tooltip(tooltipTriggerEl);
+                });
+            }
+
+            // 添加显示文本
+            function addDisplayText() {
+                const textInput = document.getElementById("text-input");
+                const text = textInput.value.trim();
+
+                if (!text) {
+                    showMessage("请输入要显示的文本", "warning");
+                    log("添加显示文本失败：未输入文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加显示文本：未连接到服务器", "danger");
+                    log("添加显示文本失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在添加显示文本: ${text.substring(0, 20)}${text.length > 20 ? '...' : ''}`);
+
+                connection.invoke("AddDisplayList", text)
+                    .then(result => {
+                        log("显示文本添加成功");
+                        showMessage("文本已添加到显示队列", "success");
+
+                        // 清空输入框
+                        textInput.value = "";
+
+                        // 刷新右侧显示文本列表
+                        loadDisplayTextList();
+                    })
+                    .catch(err => {
+                        log(`添加显示文本失败: ${err}`);
+                        showMessage("添加显示文本失败", "danger");
+                    });
+            }
+
+            // 添加显示文本并从监控列表中移除
+            function addDisplayTextAndRemoveMonitor() {
+                const textInput = document.getElementById("text-input");
+                const text = textInput.value.trim();
+
+                // 获取当前选中的监控文本项
+                const selectedMonitorItem = document.querySelector("#monitor-text-list .list-group-item.active");
+
+                if (!text) {
+                    showMessage("请输入要显示的文本", "warning");
+                    log("添加并移除操作失败：未输入文本");
+                    return;
+                }
+
+                if (!selectedMonitorItem) {
+                    showMessage("请先从左侧列表选择一条文本记录", "warning");
+                    log("添加并移除操作失败：未选择监控文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加显示文本：未连接到服务器", "danger");
+                    log("添加显示文本失败：未连接到服务器");
+                    return;
+                }
+
+                const monitorTextId = selectedMonitorItem.dataset.id;
+
+                log(`正在添加显示文本并移除监控文本: ${text.substring(0, 20)}${text.length > 20 ? '...' : ''}, ID: ${monitorTextId}`);
+
+                // 先添加显示文本
+                connection.invoke("AddDisplayList", text)
+                    .then(result => {
+                        log("显示文本添加成功，正在删除监控文本");
+
+                        // 然后删除监控文本
+                        connection.invoke("DelMonitorText", monitorTextId)
+                            .then(delResult => {
+                                if (delResult) {
+                                    log("监控文本删除成功");
+
+                                    // 从UI中移除该项
+                                    selectedMonitorItem.remove();
+
+                                    // 清空输入框
+                                    textInput.value = "";
+
+                                    // 关闭文本显示
+                                    closeTextDisplay();
+
+                                    // 刷新右侧显示文本列表
+                                    loadDisplayTextList();
+
+                                    showMessage("文本已添加到显示队列并从监控列表移除", "success");
+                                } else {
+                                    log("监控文本删除失败");
+                                    showMessage("文本已添加到显示队列，但从监控列表移除失败", "warning");
+
+                                    // 刷新右侧显示文本列表
+                                    loadDisplayTextList();
+                                }
+                            })
+                            .catch(err => {
+                                log(`删除监控文本失败: ${err}`);
+                                showMessage("文本已添加到显示队列，但从监控列表移除失败", "warning");
+
+                                // 刷新右侧显示文本列表
+                                loadDisplayTextList();
+                            });
+                    })
+                    .catch(err => {
+                        log(`添加显示文本失败: ${err}`);
+                        showMessage("添加显示文本失败", "danger");
+                    });
+            }
+
+            // 获取服务器当前的音频流设置
+            function getServerAudioStreamingSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取音频流设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前音频流设置...");
+
+                connection.invoke("GetAudioStreamingSetting")
+                    .then(enabled => {
+                        log(`获取到服务器当前音频流设置: ${enabled ? "开启" : "关闭"}`);
+                        updateAudioStreamingUI(enabled);
+                        isAudioStreamEnabled = enabled;
+                    })
+                    .catch(err => {
+                        log("获取音频流设置失败: " + err);
+                    });
+            }
+
+            // 更新音频流设置UI
+            function updateAudioStreamingUI(enabled) {
+                // 更新单选按钮状态
+                document.getElementById(`audioStreaming${enabled ? 1 : 0}`).checked = true;
+
+                // 更新本地状态
+                isAudioStreamEnabled = enabled;
+
+                log(`UI音频流设置已更新为: ${enabled ? "开启" : "关闭"}`);
+            }
+
+            // 设置音量控制监听器
+            function setupVolumeControl() {
+                const volumeSlider = document.getElementById("volumeSlider");
+                if (volumeSlider) {
+                    // 初始化滑块值为当前音量 * 音量增益系数（转换为百分比）
+                    volumeSlider.value = Math.floor(currentVolume * 100);
+
+                    // 更新显示
+                    const volumeDisplay = document.getElementById("volumeDisplay");
+                    if (volumeDisplay) {
+                        volumeDisplay.textContent = `${Math.floor(currentVolume * 100)}%`;
+                    }
+
+                    // 监听音量变化
+                    volumeSlider.addEventListener("input", function () {
+                        const newVolume = parseFloat(this.value) / 100;
+                        currentVolume = newVolume;
+
+                        // 应用音量设置（包含增益）
+                        if (audioGainNode) {
+                            audioGainNode.gain.value = newVolume * volumeBoost;
+                        }
+
+                        // 更新显示
+                        if (volumeDisplay) {
+                            volumeDisplay.textContent = `${Math.floor(newVolume * 100)}%`;
+                        }
+
+                        log(`音量已调整: ${Math.floor(newVolume * 100)}%, 实际增益: ${(newVolume * volumeBoost).toFixed(1)}`);
+                    });
+                }
+            }
+
+            // 初始化音频上下文
+            function initAudioContext() {
+                try {
+                    // 关闭现有的音频上下文
+                    if (audioContext) {
+                        try {
+                            if (audioGainNode) {
+                                audioGainNode.disconnect();
+                                audioGainNode = null;
+                            }
+                            audioContext.close().catch(e => log("关闭音频上下文失败: " + e));
+                            audioContext = null;
+                        } catch (e) {
+                            log("重置音频上下文失败: " + e);
+                        }
+                    }
+
+                    // 创建新的音频上下文
+                    const AudioContext = window.AudioContext || window.webkitAudioContext;
+                    audioContext = new AudioContext({
+                        latencyHint: 'interactive' // 低延迟设置
+                    });
+
+                    // 创建增益节点并设置更高的音量
+                    audioGainNode = audioContext.createGain();
+                    audioGainNode.gain.value = currentVolume * volumeBoost; // 应用音量增益
+                    audioGainNode.connect(audioContext.destination);
+
+                    log(`音频上下文已初始化: 采样率=${audioContext.sampleRate}Hz, 状态=${audioContext.state}, 音量增益=${volumeBoost}倍`);
+
+                    // 恢复音频上下文
+                    if (audioContext.state === 'suspended') {
+                        const resumeAudio = function () {
+                            if (audioContext && audioContext.state === 'suspended') {
+                                audioContext.resume().then(() => {
+                                    log("音频上下文已激活");
+                                }).catch(err => {
+                                    log("激活音频上下文失败: " + err);
+                                });
+                            }
+                        };
+
+                        // 设置单次事件监听
+                        document.addEventListener('click', resumeAudio, { once: true });
+                        document.addEventListener('touchstart', resumeAudio, { once: true });
+                        document.addEventListener('keydown', resumeAudio, { once: true });
+
+                        // 尝试立即恢复
+                        resumeAudio();
+                    }
+                } catch (e) {
+                    log("初始化音频上下文失败: " + e);
+                    showMessage("无法初始化音频播放: " + e, "danger");
+                }
+            }
+
+            // 播放实时音频 - 适应新格式
+            function playRealTimeAudio(audioPacket) {
+                if (!audioContext || !isAudioStreamEnabled || !callInProgress) return;
+
+                try {
+                    // 解析音频元数据和数据
+                    const { format, sampleRate, channels, data } = audioPacket;
+
+                    // 确保格式正确
+                    if (!format || !data) {
+                        log("音频格式或数据无效");
+                        return;
+                    }
+
+                    log(`接收到音频数据: 格式=${format}, 采样率=${sampleRate}, 声道=${channels}, 数据长度=${Array.isArray(data) ? data.length : '未知'}`);
+
+                    // 根据不同的音频格式处理
+                    if (format === "WAV") {
+                        // 处理WAV格式数据 - 异步解码
+                        processWavData(data, sampleRate, channels)
+                            .then(audioBuffer => {
+                                if (audioBuffer) {
+                                    playAudioBuffer(audioBuffer);
+                                } else {
+                                    log("无法创建WAV音频缓冲区");
+                                }
+                            })
+                            .catch(err => {
+                                log("WAV处理错误: " + err);
+                            });
+                    } else if (format === "16bit_PCM") {
+                        // 处理PCM格式数据 - 同步处理
+                        const audioBuffer = processPcmData(data, sampleRate, channels);
+                        if (audioBuffer) {
+                            playAudioBuffer(audioBuffer);
+                        } else {
+                            log("无法创建PCM音频缓冲区");
+                        }
+                    } else {
+                        log("不支持的音频格式: " + format);
+                    }
+                } catch (e) {
+                    log("处理实时音频失败: " + e);
+                }
+            }
+
+            // 播放音频缓冲区
+            function playAudioBuffer(audioBuffer) {
+                // 确保音频上下文活跃
+                if (audioContext.state === 'suspended') {
+                    try {
+                        audioContext.resume();
+                    } catch (e) {
+                        log("恢复音频上下文失败: " + e);
+                        return;
+                    }
+                }
+
+                // 创建音频源并连接
+                const source = audioContext.createBufferSource();
+                source.buffer = audioBuffer;
+
+                // 应用音量控制
+                source.connect(audioGainNode);
+                if (audioGainNode) {
+                    audioGainNode.gain.value = currentVolume * volumeBoost;
+                }
+
+                // 立即播放
+                source.start(0);
+                log("开始播放音频");
+            }
+
+            // 处理WAV格式的数据 - 返回Promise
+            function processWavData(data, sampleRate, channels) {
+                return new Promise((resolve, reject) => {
+                    try {
+                        // 确保音频上下文存在
+                        if (!audioContext || audioContext.state === 'closed') {
+                            initAudioContext();
+                            if (!audioContext) {
+                                reject(new Error("无法初始化音频上下文"));
+                                return;
+                            }
+                        }
+
+                        // 将数据转换为ArrayBuffer
+                        let arrayBuffer;
+                        if (data instanceof Uint8Array) {
+                            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                        } else if (Array.isArray(data)) {
+                            // 转换数组为Uint8Array
+                            const uint8Array = new Uint8Array(data);
+                            arrayBuffer = uint8Array.buffer;
+                        } else if (typeof data === 'string') {
+                            // 处理Base64编码
+                            try {
+                                const base64Str = data.trim().replace(/^data:[^;]+;base64,/, '');
+                                const binary = atob(base64Str);
+                                const uint8Array = new Uint8Array(binary.length);
+                                for (let i = 0; i < binary.length; i++) {
+                                    uint8Array[i] = binary.charCodeAt(i);
+                                }
+                                arrayBuffer = uint8Array.buffer;
+                            } catch (e) {
+                                log("WAV数据Base64解码失败: " + e);
+                                reject(e);
+                                return;
+                            }
+                        } else if (data.buffer) {
+                            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                        } else {
+                            const error = new Error("无法处理的WAV数据类型");
+                            log(error.message);
+                            reject(error);
+                            return;
+                        }
+
+                        // 使用Web Audio API解码音频
+                        audioContext.decodeAudioData(
+                            arrayBuffer,
+                            (buffer) => {
+                                log("WAV数据解码成功, 时长: " + buffer.duration.toFixed(2) + "秒");
+                                resolve(buffer);
+                            },
+                            (err) => {
+                                log("解码WAV数据失败: " + err);
+                                reject(err);
+                            }
+                        );
+                    } catch (e) {
+                        log("处理WAV数据失败: " + e);
+                        reject(e);
+                    }
+                });
+            }
+
+            // 处理PCM格式的数据
+            function processPcmData(data, sampleRate, channels) {
+                try {
+                    // 确保音频上下文存在
+                    if (!audioContext || audioContext.state === 'closed') {
+                        initAudioContext();
+                        if (!audioContext) return null;
+                    }
+
+                    // 转换数据为适合的格式
+                    let pcmData;
+                    if (data instanceof Uint8Array) {
+                        pcmData = data;
+                    } else if (Array.isArray(data)) {
+                        pcmData = new Uint8Array(data);
+                    } else if (typeof data === 'object' && data.buffer) {
+                        pcmData = new Uint8Array(data.buffer);
+                    } else if (typeof data === 'string') {
+                        try {
+                            // 处理Base64编码
+                            const base64Str = data.trim().replace(/^data:[^;]+;base64,/, '');
+                            const binary = atob(base64Str);
+                            pcmData = new Uint8Array(binary.length);
+                            for (let i = 0; i < binary.length; i++) {
+                                pcmData[i] = binary.charCodeAt(i);
+                            }
+                        } catch (e) {
+                            log("PCM数据Base64解码失败: " + e);
+                            return null;
+                        }
+                    } else {
+                        log("不支持的PCM数据类型");
+                        return null;
+                    }
+
+                    // 确保有效的数据
+                    if (!pcmData || pcmData.length < 2) {
+                        log("PCM数据无效或太短");
+                        return null;
+                    }
+
+                    // 确保数据长度是偶数（16位PCM）
+                    const validLength = Math.floor(pcmData.length / 2) * 2;
+                    if (validLength < pcmData.length) {
+                        pcmData = pcmData.slice(0, validLength);
+                    }
+
+                    try {
+                        // 从Uint8Array创建Int16Array视图
+                        let int16Data;
+
+                        try {
+                            // 创建DataView以便正确解析16位整数
+                            const dataView = new DataView(pcmData.buffer, pcmData.byteOffset, pcmData.byteLength);
+                            int16Data = new Int16Array(pcmData.length / 2);
+
+                            // 从小端字节序读取16位整数
+                            for (let i = 0; i < pcmData.length; i += 2) {
+                                if (i + 1 < pcmData.length) {
+                                    int16Data[i / 2] = dataView.getInt16(i, true); // true表示小端字节序
+                                }
+                            }
+                        } catch (e) {
+                            log("创建Int16Array失败: " + e);
+
+                            // 备用方法
+                            const newBuffer = new ArrayBuffer(pcmData.length);
+                            const newView = new Uint8Array(newBuffer);
+                            newView.set(pcmData);
+                            const dataView = new DataView(newBuffer);
+
+                            int16Data = new Int16Array(pcmData.length / 2);
+                            for (let i = 0; i < pcmData.length; i += 2) {
+                                if (i + 1 < pcmData.length) {
+                                    int16Data[i / 2] = dataView.getInt16(i, true);
+                                }
+                            }
+                        }
+
+                        // 创建音频缓冲区，使用实际采样率
+                        const audioSampleRate = sampleRate || audioContext.sampleRate;
+                        const buffer = audioContext.createBuffer(channels || 1, int16Data.length, audioSampleRate);
+
+                        // 将Int16数据转换为Float32数据并存入缓冲区
+                        const channelData = buffer.getChannelData(0);
+                        for (let i = 0; i < int16Data.length; i++) {
+                            // 将Int16转换为-1.0到1.0的Float32
+                            channelData[i] = Math.max(-1, Math.min(1, int16Data[i] / 32768.0));
+                        }
+
+                        return buffer;
+                    } catch (e) {
+                        log("PCM数据处理失败: " + e);
+                        return null;
+                    }
+                } catch (e) {
+                    log("处理PCM数据失败: " + e);
+                    return null;
+                }
+            }
+
+            // 显示实时语音识别结果
+            function showRealtimeTextResult(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容，添加一个标记表明这是实时结果
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.innerHTML = `<span class="realtime-text" style="color: #0d6efd;">${text}</span> <small class="text-muted">(实时识别中...)</small>`;
+
+                log("显示实时语音识别结果");
+            }
+
+            // 显示最终语音识别结果
+            function showFinalTextResult(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容，并标记为最终结果
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.innerHTML = `<span class="final-text">${text}</span>`;
+
+                log("显示最终语音识别结果");
+            }
+
+            // 添加文本到监控列表
+            function addToMonitorList(text) {
+                if (!text || text.trim() === "") return;
+
+                // 检查是否已经存在相同内容
+                const existingItems = document.querySelectorAll("#monitor-text-list .list-group-item");
+                for (let i = 0; i < existingItems.length; i++) {
+                    if (existingItems[i].dataset.fullText === text) {
+                        // 已存在相同内容，不需要添加
+                        return;
+                    }
+                }
+
+                // 创建新的列表项
+                const container = document.getElementById("monitor-text-list");
+                const listItem = document.createElement("div");
+                listItem.className = "list-group-item";
+                // 使用临时ID，服务器端会分配真正的ID
+                listItem.dataset.id = "temp-" + Date.now();
+                listItem.dataset.fullText = text;
+
+                // 添加点击事件
+                listItem.addEventListener('click', function (e) {
+                    // 如果点击的是按钮，不触发选择
+                    if (e.target.tagName === 'BUTTON' || e.target.tagName === 'I' ||
+                        e.target.closest('button')) {
+                        return;
+                    }
+
+                    // 移除其他项的active类
+                    document.querySelectorAll("#monitor-text-list .list-group-item").forEach(item => {
+                        item.classList.remove("active");
+                    });
+
+                    // 添加active类到当前项
+                    this.classList.add("active");
+
+                    // 显示文本
+                    displayTextInCenter(this.dataset.fullText);
+                });
+
+                // 获取当前时间
+                const date = new Date();
+                const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
+
+                // 截取前10个字符，若不足10个则全部显示
+                const shortText = text.length > 10 ? text.substring(0, 10) : text;
+
+                listItem.innerHTML = `
+                                                                <div class="d-flex justify-content-between align-items-start mb-1">
+                                                                    <small class="text-muted">【${shortText}】</small>
+                                                                    <div class="btn-group btn-group-sm">
+                                                                        <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${listItem.dataset.id}')">
+                                                                            <i class="bi bi-trash"></i>
+                                                                        </button>
+                                                                    </div>
+                                                                </div>
+                                                                <div>${formattedDate} (本地)</div>
+                                                            `;
+
+                // 添加到列表顶部
+                if (container.firstChild) {
+                    container.insertBefore(listItem, container.firstChild);
+                } else {
+                    container.appendChild(listItem);
+                }
+
+                log(`已添加文本到监控列表: ${shortText}...`);
+            }
+
+            // 更新控屏UI
+            function updateScreenControlUI(isManual) {
+                // 更新单选按钮状态
+                document.getElementById(isManual ? 'screenControlManual' : 'screenControlAuto').checked = true;
+                isManualScreenControl = isManual;
+
+                log(`UI控屏模式已更新为: ${isManual ? "手动" : "自动"}`);
+            }
+
+            // 获取服务器当前的控屏设置
+            function getServerScreenControlSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取控屏设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前控屏设置...");
+
+                connection.invoke("GetScreenControlSetting")
+                    .then(isManual => {
+                        log(`获取到服务器控屏设置: ${isManual ? "手动" : "自动"}`);
+                        updateScreenControlUI(isManual);
+                    })
+                    .catch(err => {
+                        log(`获取控屏设置失败: ${err}`);
+                        // 默认设置为自动
+                        updateScreenControlUI(false);
+                    });
+            }
+
+            // 初始化UI和事件
+            function initUI() {
+                // 查询当前选择的模式
+                if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                    // 获取当前控屏设置
+                    getServerScreenControlSetting();
+
+                    // 获取当前音频流设置
+                    getServerAudioStreamingSetting();
+
+                       // 获取当前预设句子类型设置
+                    getServerPresetSentenceTypeSetting();
+                }
+
+                // 设置工具提示
+                var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+                tooltipTriggerList.map(function (tooltipTriggerEl) {
+                    return new bootstrap.Tooltip(tooltipTriggerEl);
+                });
+            }
+
+            // 获取服务器当前预设句子类型设置
+            function getServerPresetSentenceTypeSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取预设句子类型设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前预设句子类型设置...");
+
+                connection.invoke("GetPresetSentenceType")
+                    .then(type => {
+                        log(`获取到服务器当前预设句子类型设置: ${type}`);
+                        updatePresetSentenceTypeUI(type);
+                    })
+                    .catch(err => {
+                        log("获取预设句子类型设置失败: " + err);
+                    });
+            }
+
+            // 更新预设句子类型UI
+            function updatePresetSentenceTypeUI(type) {
+                // 更新单选按钮状态
+                document.getElementById(`presetSentenceType${type}`).checked = true;
+                log(`UI预设句子类型设置已更新为: ${type}`);
+            }
+
+            // 更新预设句子类型
+            function updatePresetSentenceType(type) {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法更新预设句子类型：未连接到服务器", "danger");
+                    log("更新预设句子类型失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在更新预设句子类型: ${type}`);
+
+                connection.invoke("UpdatePresetSentenceType", type)
+                    .then(result => {
+                        if (result) {
+                            log("预设句子类型更新成功");
+                            showMessage(`预设句子类型已更新为: ${type === 0 ? '默认预设句子' : '预设句子2'}`, "success");
+                        } else {
+                            log("预设句子类型更新失败");
+                            showMessage("预设句子类型更新失败", "danger");
+                        }
+                    })
+                    .catch(err => {
+                        log(`更新预设句子类型失败: ${err}`);
+                        showMessage("更新预设句子类型失败", "danger");
+                    });
+            }
+
+            // 添加预设句子
+            function addPresetSentence() {
+                const sentenceInput = document.getElementById("presetSentenceInput");
+                const text = sentenceInput.value.trim();
+
+                if (!text) {
+                    showMessage("请输入要添加的预设句子", "warning");
+                    log("添加预设句子失败：未输入文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加预设句子：未连接到服务器", "danger");
+                    log("添加预设句子失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在添加预设句子: ${text}`);
+
+                connection.invoke("AddPresetSentence", text)
+                    .then(result => {
+                        if (result) {
+                            log("预设句子添加成功");
+                            showMessage("预设句子已添加", "success");
+                            // 清空输入框
+                            sentenceInput.value = "";
+                        } else {
+                            log("预设句子添加失败");
+                            showMessage("预设句子添加失败", "danger");
+                        }
+                    })
+                    .catch(err => {
+                        log(`添加预设句子失败: ${err}`);
+                        showMessage("添加预设句子失败", "danger");
+                    });
+            }
+
+            // 添加监听器：预设句子类型已更改
+            function setupPresetSentenceTypeListeners() {
+                connection.on("PresetSentenceTypeChanged", function (type) {
+                    log(`收到预设句子类型更改通知: ${type}`);
+                    updatePresetSentenceTypeUI(type);
+                });
+
+                connection.on("PresetSentencesUpdated", function () {
+                    log("收到预设句子更新通知");
+                    showMessage("预设句子列表已更新", "info");
+                });
+            }
+
+            // 启动连接
+            async function start() {
+                try {
+                    if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                        log("已经连接到Hub，无需重新连接");
+                        return;
+                    }
+                    debugger
+                    if (!connection) {
+                        log("初始化SignalR连接...");
+
+                        // 创建连接
+                        connection = new signalR.HubConnectionBuilder()
+                            .withUrl("/audiohub")
+                            .withAutomaticReconnect()
+                            .build();
+
+                        // 设置连接事件监听
+                        setupConnectionEventHandlers();
+
+                        // 设置消息接收处理器
+                        setupMessageHandlers();
+
+                        // 设置控屏设置变更监听器
+                        setupScreenControlListeners();
+
+                        // 设置音频流设置变更监听器
+                        setupAudioStreamingListeners();
+
+                        // 设置预设句子类型变更监听器
+                        setupPresetSentenceTypeListeners();
+                    }
+
+                    log("正在连接到Hub...");
+                    await connection.start();
+                    log("成功连接到Hub");
+
+                    // 注册为监控客户端
+                    await connection.invoke("RegisterClient", "monitor");
+                    log("已注册为监控客户端");
+
+                    // 加载文本列表
+                    loadTextLists();
+
+                    // 初始化音频上下文
+                    initAudioContext();
+
+                    // 启用实时音频流
+                    isAudioStreamEnabled = true;
+
+                    // 初始化UI和事件
+                    initUI();
+
+                } catch (err) {
+                    log(`连接失败：${err}`);
+                    setTimeout(start, 5000); // 5秒后重试
+                }
+            }
+        </script>
+    }
diff --git a/ShengShengBuXi/Pages/Admin.cshtml b/ShengShengBuXi/Pages/Admin.cshtml
index 6c79a10..d19e542 100644
--- a/ShengShengBuXi/Pages/Admin.cshtml
+++ b/ShengShengBuXi/Pages/Admin.cshtml
@@ -20,7 +20,7 @@
     </div>
 
     <!-- 消息区域 -->
-    <div id="message-area"></div>
+    <div id="message-area" style="position: fixed; bottom: 20px; right: 20px; max-width: 350px; z-index: 9999;"></div>
 
     <!-- 主要内容区域 -->
     <div class="row">
@@ -28,33 +28,43 @@
             <div class="card">
                 <div class="card-body">
                     <ul class="nav nav-tabs" id="myTab" role="tablist">
-                        <li class="nav-item" role="presentation">
+                        <!--    <li class="nav-item" role="presentation">
                             <button class="nav-link active" id="config-tab" data-bs-toggle="tab" data-bs-target="#config" type="button" role="tab" aria-controls="config" aria-selected="true">系统配置</button>
+                        </li> -->
+                        <li class="nav-item" role="presentation"></li>
+                        <button class="nav-link" id="recordings-tab" data-bs-toggle="tab" data-bs-target="#recordings"
+                            type="button" role="tab" aria-controls="recordings" aria-selected="false">用户留言</button>
                         </li>
                         <li class="nav-item" role="presentation">
-                            <button class="nav-link" id="clients-tab" data-bs-toggle="tab" data-bs-target="#clients" type="button" role="tab" aria-controls="clients" aria-selected="false">客户端</button>
+                            <button class="nav-link" id="clients-tab" data-bs-toggle="tab" data-bs-target="#clients"
+                                type="button" role="tab" aria-controls="clients" aria-selected="false">客户端</button>
                         </li>
-                        <li class="nav-item" role="presentation">
-                            <button class="nav-link" id="recordings-tab" data-bs-toggle="tab" data-bs-target="#recordings" type="button" role="tab" aria-controls="recordings" aria-selected="false">录音管理</button>
-                        </li>
-                        <li class="nav-item" role="presentation">
+
+                        <!--  <li class="nav-item" role="presentation">
                             <button class="nav-link" id="recognition-tab" data-bs-toggle="tab" data-bs-target="#recognition" type="button" role="tab" aria-controls="recognition" aria-selected="false">识别结果</button>
+                        </li>-->
+                        <li class="nav-item" role="presentation"></li>
+                        <button class="nav-link" id="display-config-tab" data-bs-toggle="tab"
+                            data-bs-target="#display-config" type="button" role="tab" aria-controls="display-config"
+                            aria-selected="false">显示配置</button>
                         </li>
                         <li class="nav-item" role="presentation">
-                            <button class="nav-link" id="display-config-tab" data-bs-toggle="tab" data-bs-target="#display-config" type="button" role="tab" aria-controls="display-config" aria-selected="false">显示配置</button>
-                        </li>
-                        <li class="nav-item" role="presentation">
-                            <button class="nav-link" id="user-records-tab" data-bs-toggle="tab" data-bs-target="#user-records" type="button" role="tab" aria-controls="user-records" aria-selected="false">用户记录</button>
+                            <button class="nav-link" id="user-records-tab" data-bs-toggle="tab"
+                                data-bs-target="#user-records" type="button" role="tab" aria-controls="user-records"
+                                aria-selected="false">用户记录</button>
                         </li>
                     </ul>
                     <div class="tab-content" id="myTabContent">
                         <!-- 系统配置 -->
-                        <div class="tab-pane fade show active" id="config" role="tabpanel" aria-labelledby="config-tab">
+                        <div class="tab-pane fade  " id="config" role="tabpanel" aria-labelledby="config-tab">
                             <form id="config-form" class="mt-3">
                                 <div class="d-flex justify-content-end mb-3">
-                                    <button type="button" class="btn btn-success me-2" onclick="saveConfig()">保存配置</button>
-                                    <button type="button" class="btn btn-primary me-2" onclick="getLatestConfig()">刷新配置</button>
-                                    <button type="button" class="btn btn-secondary" onclick="exportConfig()">导出配置</button>
+                                    <button type="button" class="btn btn-success me-2"
+                                        onclick="saveConfig()">保存配置</button>
+                                    <button type="button" class="btn btn-primary me-2"
+                                        onclick="getLatestConfig()">刷新配置</button>
+                                    <button type="button" class="btn btn-secondary"
+                                        onclick="exportConfig()">导出配置</button>
                                 </div>
 
                                 <div class="row">
@@ -63,44 +73,53 @@
                                         <h5>控制台配置</h5>
                                         <div class="mb-3">
                                             <label for="serverUrl" class="form-label">服务器地址</label>
-                                            <input type="text" class="form-control" id="serverUrl" name="network.serverUrl">
+                                            <input type="text" class="form-control" id="serverUrl"
+                                                name="network.serverUrl">
                                             <div class="form-text">WebSocket服务器地址</div>
                                         </div>
                                         <div class="mb-3">
                                             <label for="reconnectAttempts" class="form-label">重连尝试次数</label>
-                                            <input type="number" class="form-control" id="reconnectAttempts" name="network.reconnectAttempts">
+                                            <input type="number" class="form-control" id="reconnectAttempts"
+                                                name="network.reconnectAttempts">
                                         </div>
                                         <div class="mb-3">
                                             <label for="reconnectDelayMs" class="form-label">重连延迟（毫秒）</label>
-                                            <input type="number" class="form-control" id="reconnectDelayMs" name="network.reconnectDelayMs">
+                                            <input type="number" class="form-control" id="reconnectDelayMs"
+                                                name="network.reconnectDelayMs">
                                         </div>
                                         <div class="mb-3 form-check">
-                                            <input type="checkbox" class="form-check-input" id="enableSpeechToText" name="network.enableSpeechToText">
+                                            <input type="checkbox" class="form-check-input" id="enableSpeechToText"
+                                                name="network.enableSpeechToText">
                                             <label class="form-check-label" for="enableSpeechToText">启用语音识别</label>
                                         </div>
                                         <div class="mb-3 form-check">
-                                            <input type="checkbox" class="form-check-input" id="enableAudioStreaming" name="network.enableAudioStreaming">
+                                            <input type="checkbox" class="form-check-input" id="enableAudioStreaming"
+                                                name="network.enableAudioStreaming">
                                             <label class="form-check-label" for="enableAudioStreaming">启用音频流传输</label>
                                         </div>
                                         <div class="mb-3">
                                             <label for="heartbeatIntervalSeconds" class="form-label">心跳间隔（秒）</label>
-                                            <input type="number" class="form-control" id="heartbeatIntervalSeconds" name="network.heartbeatIntervalSeconds">
+                                            <input type="number" class="form-control" id="heartbeatIntervalSeconds"
+                                                name="network.heartbeatIntervalSeconds">
                                         </div>
 
                                         <h5 class="mt-4">拨号配置</h5>
                                         <div class="mb-3">
                                             <label for="minDigitsToDialOut" class="form-label">拨号最小位数</label>
-                                            <input type="number" class="form-control" id="minDigitsToDialOut" name="dial.minDigitsToDialOut">
+                                            <input type="number" class="form-control" id="minDigitsToDialOut"
+                                                name="dial.minDigitsToDialOut">
                                             <div class="form-text">拨号所需的最小位数</div>
                                         </div>
                                         <div class="mb-3">
                                             <label for="autoDialOutAfterSeconds" class="form-label">自动拨出等待时间（秒）</label>
-                                            <input type="number" class="form-control" id="autoDialOutAfterSeconds" name="dial.autoDialOutAfterSeconds">
+                                            <input type="number" class="form-control" id="autoDialOutAfterSeconds"
+                                                name="dial.autoDialOutAfterSeconds">
                                             <div class="form-text">无新按键后自动拨出的等待秒数</div>
                                         </div>
                                         <div class="mb-3">
                                             <label for="resetTimeoutSeconds" class="form-label">重置超时时间（秒）</label>
-                                            <input type="number" class="form-control" id="resetTimeoutSeconds" name="dial.resetTimeoutSeconds">
+                                            <input type="number" class="form-control" id="resetTimeoutSeconds"
+                                                name="dial.resetTimeoutSeconds">
                                             <div class="form-text">位数不足时，无操作重置的等待秒数</div>
                                         </div>
                                     </div>
@@ -110,57 +129,72 @@
                                         <h5>录音配置</h5>
                                         <div class="mb-3">
                                             <label for="recordingFolder" class="form-label">录音保存文件夹</label>
-                                            <input type="text" class="form-control" id="recordingFolder" name="recording.recordingFolder">
+                                            <input type="text" class="form-control" id="recordingFolder"
+                                                name="recording.recordingFolder">
                                         </div>
                                         <div class="mb-3">
                                             <label for="recordingDeviceNumber" class="form-label">录音设备编号</label>
-                                            <input type="number" class="form-control" id="recordingDeviceNumber" name="recording.recordingDeviceNumber">
+                                            <input type="number" class="form-control" id="recordingDeviceNumber"
+                                                name="recording.recordingDeviceNumber">
                                         </div>
                                         <div class="mb-3">
                                             <label for="sampleRate" class="form-label">采样率</label>
-                                            <input type="number" class="form-control" id="sampleRate" name="recording.sampleRate">
+                                            <input type="number" class="form-control" id="sampleRate"
+                                                name="recording.sampleRate">
                                         </div>
                                         <div class="mb-3">
                                             <label for="channels" class="form-label">声道数</label>
-                                            <input type="number" class="form-control" id="channels" name="recording.channels">
+                                            <input type="number" class="form-control" id="channels"
+                                                name="recording.channels">
                                             <div class="form-text">1=单声道，2=立体声</div>
                                         </div>
                                         <div class="mb-3">
                                             <label for="bufferMilliseconds" class="form-label">缓冲区大小（毫秒）</label>
-                                            <input type="number" class="form-control" id="bufferMilliseconds" name="recording.bufferMilliseconds">
+                                            <input type="number" class="form-control" id="bufferMilliseconds"
+                                                name="recording.bufferMilliseconds">
                                         </div>
                                         <div class="mb-3">
                                             <label for="silenceThreshold" class="form-label">静音检测阈值</label>
-                                            <input type="number" class="form-control" id="silenceThreshold" name="recording.silenceThreshold" step="0.01">
+                                            <input type="number" class="form-control" id="silenceThreshold"
+                                                name="recording.silenceThreshold" step="0.01">
                                         </div>
                                         <div class="mb-3">
                                             <label for="silenceTimeoutSeconds" class="form-label">静音超时时间（秒）</label>
-                                            <input type="number" class="form-control" id="silenceTimeoutSeconds" name="recording.silenceTimeoutSeconds">
+                                            <input type="number" class="form-control" id="silenceTimeoutSeconds"
+                                                name="recording.silenceTimeoutSeconds">
                                             <div class="form-text">无声音自动挂断的时间</div>
                                         </div>
                                         <div class="mb-3 form-check">
-                                            <input type="checkbox" class="form-check-input" id="allowUserHangup" name="recording.allowUserHangup">
+                                            <input type="checkbox" class="form-check-input" id="allowUserHangup"
+                                                name="recording.allowUserHangup">
                                             <label class="form-check-label" for="allowUserHangup">允许用户手动挂断</label>
                                         </div>
                                         <div class="mb-3 form-check">
-                                            <input type="checkbox" class="form-check-input" id="uploadRecordingToServer" name="recording.uploadRecordingToServer">
-                                            <label class="form-check-label" for="uploadRecordingToServer">上传录音文件到服务器</label>
+                                            <input type="checkbox" class="form-check-input" id="uploadRecordingToServer"
+                                                name="recording.uploadRecordingToServer">
+                                            <label class="form-check-label"
+                                                for="uploadRecordingToServer">上传录音文件到服务器</label>
                                         </div>
                                         <div class="mb-3">
                                             <label for="recordingsFolder" class="form-label">服务器录音路径</label>
-                                            <input type="text" class="form-control" id="recordingsFolder" name="recording.recordingsFolder">
+                                            <input type="text" class="form-control" id="recordingsFolder"
+                                                name="recording.recordingsFolder">
                                         </div>
                                         <div class="mb-3">
                                             <label for="fileNameFormat" class="form-label">录音文件名格式</label>
-                                            <input type="text" class="form-control" id="fileNameFormat" name="recording.fileNameFormat">
+                                            <input type="text" class="form-control" id="fileNameFormat"
+                                                name="recording.fileNameFormat">
                                         </div>
                                         <div class="mb-3 form-check">
-                                            <input type="checkbox" class="form-check-input" id="autoCleanupOldRecordings" name="recording.autoCleanupOldRecordings">
-                                            <label class="form-check-label" for="autoCleanupOldRecordings">自动清理旧录音</label>
+                                            <input type="checkbox" class="form-check-input"
+                                                id="autoCleanupOldRecordings" name="recording.autoCleanupOldRecordings">
+                                            <label class="form-check-label"
+                                                for="autoCleanupOldRecordings">自动清理旧录音</label>
                                         </div>
                                         <div class="mb-3">
                                             <label for="keepRecordingsDays" class="form-label">保留录音天数</label>
-                                            <input type="number" class="form-control" id="keepRecordingsDays" name="recording.keepRecordingsDays">
+                                            <input type="number" class="form-control" id="keepRecordingsDays"
+                                                name="recording.keepRecordingsDays">
                                             <div class="form-text">启用自动清理时有效</div>
                                         </div>
                                     </div>
@@ -172,31 +206,38 @@
                                         <h5>音频文件配置</h5>
                                         <div class="mb-3">
                                             <label for="audioBasePath" class="form-label">音频文件基础路径</label>
-                                            <input type="text" class="form-control" id="audioBasePath" name="audioFiles.audioBasePath">
+                                            <input type="text" class="form-control" id="audioBasePath"
+                                                name="audioFiles.audioBasePath">
                                         </div>
                                         <div class="mb-3">
                                             <label for="waitingToneFile" class="form-label">等待嘟音文件</label>
-                                            <input type="text" class="form-control" id="waitingToneFile" name="audioFiles.waitingToneFile">
+                                            <input type="text" class="form-control" id="waitingToneFile"
+                                                name="audioFiles.waitingToneFile">
                                         </div>
                                         <div class="mb-3">
                                             <label for="waitForPickupFile" class="form-label">等待接电话音频</label>
-                                            <input type="text" class="form-control" id="waitForPickupFile" name="audioFiles.waitForPickupFile">
+                                            <input type="text" class="form-control" id="waitForPickupFile"
+                                                name="audioFiles.waitForPickupFile">
                                         </div>
                                         <div class="mb-3">
                                             <label for="phonePickupFile" class="form-label">电话接起音频</label>
-                                            <input type="text" class="form-control" id="phonePickupFile" name="audioFiles.phonePickupFile">
+                                            <input type="text" class="form-control" id="phonePickupFile"
+                                                name="audioFiles.phonePickupFile">
                                         </div>
                                         <div class="mb-3">
                                             <label for="promptUserRecordFile" class="form-label">提示用户录音音频</label>
-                                            <input type="text" class="form-control" id="promptUserRecordFile" name="audioFiles.promptUserRecordFile">
+                                            <input type="text" class="form-control" id="promptUserRecordFile"
+                                                name="audioFiles.promptUserRecordFile">
                                         </div>
                                         <div class="mb-3">
                                             <label for="beepPromptFile" class="form-label">提示音文件</label>
-                                            <input type="text" class="form-control" id="beepPromptFile" name="audioFiles.beepPromptFile">
+                                            <input type="text" class="form-control" id="beepPromptFile"
+                                                name="audioFiles.beepPromptFile">
                                         </div>
                                         <div class="mb-3">
                                             <label for="digitToneFileTemplate" class="form-label">数字按键音频模板</label>
-                                            <input type="text" class="form-control" id="digitToneFileTemplate" name="audioFiles.digitToneFileTemplate">
+                                            <input type="text" class="form-control" id="digitToneFileTemplate"
+                                                name="audioFiles.digitToneFileTemplate">
                                             <div class="form-text">例如: {0}.mp3，用于数字0-9的按键音</div>
                                         </div>
                                     </div>
@@ -206,17 +247,20 @@
                                         <h5>电话流程配置</h5>
                                         <div class="mb-3">
                                             <label for="waitForPickupMinSeconds" class="form-label">等待接听最小时间（秒）</label>
-                                            <input type="number" class="form-control" id="waitForPickupMinSeconds" name="callFlow.waitForPickupMinSeconds">
+                                            <input type="number" class="form-control" id="waitForPickupMinSeconds"
+                                                name="callFlow.waitForPickupMinSeconds">
                                             <div class="form-text">等待接电话音频的最小持续时间</div>
                                         </div>
                                         <div class="mb-3">
                                             <label for="waitForPickupMaxSeconds" class="form-label">等待接听最大时间（秒）</label>
-                                            <input type="number" class="form-control" id="waitForPickupMaxSeconds" name="callFlow.waitForPickupMaxSeconds">
+                                            <input type="number" class="form-control" id="waitForPickupMaxSeconds"
+                                                name="callFlow.waitForPickupMaxSeconds">
                                             <div class="form-text">等待接电话音频的最大持续时间</div>
                                         </div>
                                         <div class="mb-3">
                                             <label for="playPickupProbability" class="form-label">接听概率</label>
-                                            <input type="number" class="form-control" id="playPickupProbability" name="callFlow.playPickupProbability" step="0.01" min="0" max="1">
+                                            <input type="number" class="form-control" id="playPickupProbability"
+                                                name="callFlow.playPickupProbability" step="0.01" min="0" max="1">
                                             <div class="form-text">播放电话接起音频的概率（0-1之间）</div>
                                         </div>
                                     </div>
@@ -225,7 +269,7 @@
                         </div>
 
                         <!-- 客户端管理 -->
-                        <div class="tab-pane fade" id="clients" role="tabpanel" aria-labelledby="clients-tab">
+                        <div class="tab-pane fade" show id="clients" role="tabpanel" aria-labelledby="clients-tab">
                             <div class="mt-3">
                                 <table class="table table-striped">
                                     <thead>
@@ -247,15 +291,16 @@
                         </div>
 
                         <!-- 录音管理 -->
-                        <div class="tab-pane fade" id="recordings" role="tabpanel" aria-labelledby="recordings-tab">
+                        <div class="tab-pane fade show active" id="recordings" role="tabpanel" aria-labelledby="recordings-tab">
                             <div class="mt-3">
                                 <button class="btn btn-primary mb-3" onclick="getRecentRecordings()">刷新录音列表</button>
 
-                                <!-- 音频播放器 -->
+                                <!-- 音频播放器（将不再全局显示，而是嵌入到表格行中） -->
                                 <div class="card mb-3" id="audioPlayerCard" style="display: none;">
                                     <div class="card-header d-flex justify-content-between">
                                         <span id="currentPlayingFile">当前播放：</span>
-                                        <button class="btn btn-sm btn-outline-secondary" onclick="closeAudioPlayer()">关闭</button>
+                                        <button class="btn btn-sm btn-outline-secondary"
+                                            onclick="closeAudioPlayer()">关闭</button>
                                     </div>
                                     <div class="card-body">
                                         <audio id="audioPlayer" controls class="w-100">
@@ -302,12 +347,16 @@
                         </div>
 
                         <!-- 显示配置 -->
-                        <div class="tab-pane fade" id="display-config" role="tabpanel" aria-labelledby="display-config-tab">
+                        <div class="tab-pane fade" id="display-config" role="tabpanel"
+                            aria-labelledby="display-config-tab">
                             <div class="mt-3">
                                 <div class="d-flex justify-content-end mb-3">
-                                    <button type="button" class="btn btn-success me-2" onclick="saveDisplayConfig()">保存配置</button>
-                                    <button type="button" class="btn btn-primary me-2" onclick="getDisplayConfig()">刷新配置</button>
-                                    <button type="button" class="btn btn-secondary" onclick="resetDisplayConfig()">重置默认值</button>
+                                    <button type="button" class="btn btn-success me-2"
+                                        onclick="saveDisplayConfig()">保存配置</button>
+                                    <button type="button" class="btn btn-primary me-2"
+                                        onclick="getDisplayConfig()">刷新配置</button>
+                                    <button type="button" class="btn btn-secondary"
+                                        onclick="resetDisplayConfig()">重置默认值</button>
                                 </div>
 
                                 <form id="display-config-form" class="mt-3">
@@ -320,18 +369,24 @@
                                                 </div>
                                                 <div class="card-body">
                                                     <div class="mb-3">
-                                                        <label for="leftTurnPageHeight" class="form-label">翻页高度比例</label>
-                                                        <input type="number" class="form-control" id="leftTurnPageHeight" step="0.1" min="0.1" max="1.0" value="0.8">
+                                                        <label for="leftTurnPageHeight"
+                                                            class="form-label">翻页高度比例</label>
+                                                        <input type="number" class="form-control"
+                                                            id="leftTurnPageHeight" step="0.1" min="0.1" max="1.0"
+                                                            value="0.8">
                                                         <div class="form-text">页面高度比例，值范围0.1-1.0</div>
                                                     </div>
                                                     <div class="mb-3">
                                                         <label for="leftFontSize" class="form-label">字体大小</label>
-                                                        <input type="text" class="form-control" id="leftFontSize" value="16px">
+                                                        <input type="text" class="form-control" id="leftFontSize"
+                                                            value="16px">
                                                         <div class="form-text">左侧历史记录字体大小，例如16px</div>
                                                     </div>
                                                     <div class="mb-3">
-                                                        <label for="leftTypewriterSpeed" class="form-label">打字效果速度</label>
-                                                        <input type="number" class="form-control" id="leftTypewriterSpeed" min="10" max="500" value="50">
+                                                        <label for="leftTypewriterSpeed"
+                                                            class="form-label">打字效果速度</label>
+                                                        <input type="number" class="form-control"
+                                                            id="leftTypewriterSpeed" min="10" max="500" value="50">
                                                         <div class="form-text">数值越小，打字效果速度越快</div>
                                                     </div>
                                                 </div>
@@ -347,7 +402,8 @@
                                                 <div class="card-body">
                                                     <div class="mb-3">
                                                         <label for="rightFontSize" class="form-label">字体大小</label>
-                                                        <input type="text" class="form-control" id="rightFontSize" value="24px">
+                                                        <input type="text" class="form-control" id="rightFontSize"
+                                                            value="24px">
                                                         <div class="form-text">右侧主要显示文本的字体大小</div>
                                                     </div>
                                                     <div class="mb-3">
@@ -367,8 +423,10 @@
                                                         </select>
                                                     </div>
                                                     <div class="mb-3">
-                                                        <label for="rightTypewriterSpeed" class="form-label">打字效果速度</label>
-                                                        <input type="number" class="form-control" id="rightTypewriterSpeed" min="10" max="500" value="50">
+                                                        <label for="rightTypewriterSpeed"
+                                                            class="form-label">打字效果速度</label>
+                                                        <input type="number" class="form-control"
+                                                            id="rightTypewriterSpeed" min="10" max="500" value="50">
                                                         <div class="form-text">数值越小，打字效果速度越快</div>
                                                     </div>
                                                 </div>
@@ -383,37 +441,51 @@
                                                 </div>
                                                 <div class="card-body">
                                                     <div class="mb-3 form-check">
-                                                        <input type="checkbox" class="form-check-input" id="waterEffectEnabled" checked>
-                                                        <label class="form-check-label" for="waterEffectEnabled">启用水波纹效果</label>
+                                                        <input type="checkbox" class="form-check-input"
+                                                            id="waterEffectEnabled" checked>
+                                                        <label class="form-check-label"
+                                                            for="waterEffectEnabled">启用水波纹效果</label>
                                                     </div>
                                                     <div class="mb-3">
-                                                        <label for="waterMinInterval" class="form-label">最小间隔(毫秒)</label>
-                                                        <input type="number" class="form-control" id="waterMinInterval" min="100" max="5000" value="800">
+                                                        <label for="waterMinInterval"
+                                                            class="form-label">最小间隔(毫秒)</label>
+                                                        <input type="number" class="form-control" id="waterMinInterval"
+                                                            min="100" max="5000" value="800">
                                                     </div>
                                                     <div class="mb-3">
-                                                        <label for="waterMaxInterval" class="form-label">最大间隔(毫秒)</label>
-                                                        <input type="number" class="form-control" id="waterMaxInterval" min="100" max="10000" value="2000">
+                                                        <label for="waterMaxInterval"
+                                                            class="form-label">最大间隔(毫秒)</label>
+                                                        <input type="number" class="form-control" id="waterMaxInterval"
+                                                            min="100" max="10000" value="2000">
                                                     </div>
                                                     <div class="mb-3">
-                                                        <label for="waterSimultaneousDrops" class="form-label">同时涟漪数量</label>
-                                                        <input type="number" class="form-control" id="waterSimultaneousDrops" min="1" max="10" value="3">
+                                                        <label for="waterSimultaneousDrops"
+                                                            class="form-label">同时涟漪数量</label>
+                                                        <input type="number" class="form-control"
+                                                            id="waterSimultaneousDrops" min="1" max="10" value="3">
                                                     </div>
                                                     <div class="mb-3">
                                                         <label for="waterFadeOutSpeed" class="form-label">淡出速度</label>
-                                                        <input type="number" class="form-control" id="waterFadeOutSpeed" min="0.01" max="1" step="0.01" value="0.1">
+                                                        <input type="number" class="form-control" id="waterFadeOutSpeed"
+                                                            min="0.01" max="1" step="0.01" value="0.1">
                                                     </div>
                                                     <div class="mb-3">
                                                         <label for="waterCenterBias" class="form-label">中心倾向</label>
-                                                        <input type="number" class="form-control" id="waterCenterBias" min="0" max="1" step="0.1" value="0.5">
+                                                        <input type="number" class="form-control" id="waterCenterBias"
+                                                            min="0" max="1" step="0.1" value="0.5">
                                                         <div class="form-text">0表示随机，1表示集中在中心</div>
                                                     </div>
                                                     <div class="mb-3">
-                                                        <label for="waterLargeDropProbability" class="form-label">大水滴概率</label>
-                                                        <input type="number" class="form-control" id="waterLargeDropProbability" min="0" max="1" step="0.1" value="0.2">
+                                                        <label for="waterLargeDropProbability"
+                                                            class="form-label">大水滴概率</label>
+                                                        <input type="number" class="form-control"
+                                                            id="waterLargeDropProbability" min="0" max="1" step="0.1"
+                                                            value="0.2">
                                                     </div>
                                                     <div class="mb-3">
                                                         <label for="waterLargeDropSize" class="form-label">大水滴大小</label>
-                                                        <input type="number" class="form-control" id="waterLargeDropSize" min="3" max="20" value="9">
+                                                        <input type="number" class="form-control"
+                                                            id="waterLargeDropSize" min="3" max="20" value="9">
                                                     </div>
                                                 </div>
                                             </div>
@@ -427,7 +499,8 @@
                         <div class="tab-pane fade" id="user-records" role="tabpanel" aria-labelledby="user-records-tab">
                             <div class="mt-3">
                                 <div class="d-flex justify-content-end mb-3">
-                                    <button type="button" class="btn btn-primary" onclick="getRealUserRecords()">刷新记录</button>
+                                    <button type="button" class="btn btn-primary"
+                                        onclick="getRealUserRecords()">刷新记录</button>
                                 </div>
 
                                 <div class="table-responsive">
@@ -456,7 +529,7 @@
 </div>
 
 @section Scripts {
-@* <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/6.0.6/signalr.min.js"></script> *@
+    @* <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/6.0.6/signalr.min.js"></script> *@
     <script src="~/lib/microsoft-signalr/signalr.min.js"></script>
 
     <script>
@@ -493,11 +566,12 @@
         function showMessage(message, type = 'info') {
             const messageArea = document.getElementById("message-area");
             const alert = document.createElement("div");
-            alert.className = `alert alert-${type} alert-dismissible fade show`;
+            alert.className = `alert alert-${type} alert-dismissible fade show mb-2`;
+            alert.style.boxShadow = "0 4px 8px rgba(0,0,0,0.1)";
             alert.innerHTML = `
-                ${message}
-                <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
-            `;
+                    ${message}
+                    <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+                `;
             messageArea.appendChild(alert);
 
             // 5秒后自动移除
@@ -522,7 +596,7 @@
                 .withUrl("/audioHub")
                 .withAutomaticReconnect()
                 .build();
-                // 注册连接事件处理程序
+            // 注册连接事件处理程序
             connection.onreconnecting(error => {
                 log("重新连接中: " + (error ? error.message : "未知错误"));
                 updateConnectionStatus("重连中...", "warning");
@@ -530,39 +604,42 @@
 
 
             // 设置连接状态变化的处理
-         //   setConnectionStatusHandlers();
+            //   setConnectionStatusHandlers();
 
             // 设置消息处理
-            connection.on("ReceiveServerMessage", function(message) {
+            connection.on("ReceiveServerMessage", function (message) {
                 log("服务器消息: " + message);
                 showMessage(message);
             });
 
             // 启动连接
             connection.start()
-                .then(function() {
+                .then(function () {
                     log("SignalR连接成功");
                     updateConnectionStatus("已连接", "success");
 
+                    // 设置SignalR事件处理器
+                    setupSignalRHandlers();
+
                     // 注册为管理员客户端
                     connection.invoke("RegisterClient", 1, "WebAdmin")
-                        .then(function() {
+                        .then(function () {
                             log("注册为管理员客户端成功");
                             // 获取最新配置
                             getLatestConfig();
                             // 获取显示配置
                             getDisplayConfig();
                             // 获取客户端列表
-                            //getClientList();
+                            getClientList();
                             setTimeout(getRecentRecordings, 1000);
                             setTimeout(getRealUserRecords, 1500);
                         })
-                        .catch(function(err) {
+                        .catch(function (err) {
                             log("注册为管理员客户端失败: " + err);
                             showMessage("注册为管理员客户端失败，请刷新页面重试", "danger");
                         });
                 })
-                .catch(function(err) {
+                .catch(function (err) {
                     log("SignalR连接失败: " + err);
                     updateConnectionStatus("连接失败", "danger");
                     setTimeout(initSignalR, 5000); // 5秒后重试
@@ -1023,41 +1100,83 @@
         }
 
         // 在页面中播放录音
-        function playRecordingInPage(fileName) {
-            const audioPlayer = document.getElementById("audioPlayer");
-            const audioPlayerCard = document.getElementById("audioPlayerCard");
-            const currentPlayingFile = document.getElementById("currentPlayingFile");
-
-            // 设置音频源
-            audioPlayer.src = `/recordings/${fileName}`;
-
-            // 更新显示信息
-            currentPlayingFile.textContent = `当前播放：${fileName}`;
-
-            // 显示播放器
-            audioPlayerCard.style.display = "block";
-
-            // 开始播放
-            audioPlayer.play().catch(err => {
-                log("播放失败: " + err);
-                showMessage("播放失败: " + err, "danger");
-            });
-
-            // 滚动到播放器位置
-            audioPlayerCard.scrollIntoView({ behavior: 'smooth' });
+        function playRecordingInPage(fileName, rowElement) {
+            // 关闭任何已打开的播放器
+            closeAudioPlayer();
+            
+            // 创建一个新的播放器行
+            const playerRow = document.createElement("tr");
+            playerRow.id = "inline-player-row";
+            playerRow.className = "audio-player-row";
+            
+            // 创建带有播放器的单元格
+            const playerCell = document.createElement("td");
+            playerCell.colSpan = 5;
+            playerCell.className = "p-0";
+            
+            // 创建播放器卡片
+            const playerCard = document.createElement("div");
+            playerCard.className = "card";
+            playerCard.style.border = "none";
+            playerCard.style.borderRadius = "0";
+            playerCard.style.boxShadow = "inset 0 3px 6px rgba(0,0,0,0.1)";
+            playerCard.style.backgroundColor = "#f8f9fa";
+            
+            // 创建卡片内容
+            playerCard.innerHTML = `
+                <div class="card-body py-2">
+                    <div class="d-flex justify-content-between align-items-center mb-2">
+                        <span class="text-muted">正在播放：${fileName}</span>
+                        <button class="btn btn-sm btn-outline-secondary" onclick="closeAudioPlayer()">关闭</button>
+                    </div>
+                    <audio controls class="w-100" autoplay>
+                        <source src="/recordings/${fileName}" type="audio/wav">
+                        您的浏览器不支持音频播放器
+                    </audio>
+                </div>
+            `;
+            
+            // 组装播放器行
+            playerCell.appendChild(playerCard);
+            playerRow.appendChild(playerCell);
+            
+            // 插入到表格中点击的行的后面
+            const targetRow = rowElement.closest('tr');
+            if (targetRow && targetRow.parentNode) {
+                targetRow.parentNode.insertBefore(playerRow, targetRow.nextSibling);
+                
+                // 将选中行标记为活动
+                targetRow.classList.add("table-primary");
+            }
         }
 
         // 关闭音频播放器
         function closeAudioPlayer() {
-            const audioPlayer = document.getElementById("audioPlayer");
+            // 移除任何内联播放器行
+            const playerRow = document.getElementById("inline-player-row");
+            if (playerRow) {
+                // 找到激活的行并移除高亮
+                const activeRow = document.querySelector("#recording-list tr.table-primary");
+                if (activeRow) {
+                    activeRow.classList.remove("table-primary");
+                }
+                
+                // 移除播放器行
+                playerRow.remove();
+            }
+            
+            // 隐藏原来的顶部播放器（兼容性保留）
             const audioPlayerCard = document.getElementById("audioPlayerCard");
-
-            // 暂停播放
-            audioPlayer.pause();
-            audioPlayer.src = '';
-
-            // 隐藏播放器
-            audioPlayerCard.style.display = "none";
+            if (audioPlayerCard) {
+                audioPlayerCard.style.display = "none";
+                
+                // 停止原播放器
+                const audioPlayer = document.getElementById("audioPlayer");
+                if (audioPlayer) {
+                    audioPlayer.pause();
+                    audioPlayer.src = '';
+                }
+            }
         }
 
         // 设置SignalR事件处理程序
@@ -1235,12 +1354,12 @@
             }
 
             row.innerHTML = `
-                <td>${client.clientId.substring(0, 8)}...</td>
-                <td>${client.name}</td>
-                <td>${clientType}</td>
-                <td>${client.ipAddress}</td>
-                <td><span class="badge bg-success">在线</span></td>
-            `;
+                    <td>${client.clientId.substring(0, 8)}...</td>
+                    <td>${client.name}</td>
+                    <td>${clientType}</td>
+                    <td>${client.ipAddress}</td>
+                    <td><span class="badge bg-success">在线</span></td>
+                `;
 
             tableBody.appendChild(row);
         }
@@ -1278,12 +1397,12 @@
 
                 const timestamp = new Date().toLocaleTimeString();
                 item.innerHTML = `
-                    <div class="d-flex w-100 justify-content-between">
-                        <h6 class="mb-1">${result.text}</h6>
-                        <small>${timestamp}</small>
-                    </div>
-                    <p class="mb-1">可信度: ${(result.confidence * 100).toFixed(1)}%</p>
-                `;
+                        <div class="d-flex w-100 justify-content-between">
+                            <h6 class="mb-1">${result.text}</h6>
+                            <small>${timestamp}</small>
+                        </div>
+                        <p class="mb-1">可信度: ${(result.confidence * 100).toFixed(1)}%</p>
+                    `;
 
                 // 添加到顶部
                 if (history.firstChild) {
@@ -1340,15 +1459,15 @@
                 const sequenceNumber = index + 1;
 
                 row.innerHTML = `
-                    <td>${sequenceNumber}</td>
-                    <td>${fileName}</td>
-                    <td>获取中...</td>
-                    <td>${createDate}</td>
-                    <td>
-                        <button class="btn btn-sm btn-primary" onclick="playRecordingInPage('${fileName}')">播放</button>
-                        <a href="/recordings/${fileName}" class="btn btn-sm btn-secondary" download>下载</a>
-                    </td>
-                `;
+                        <td>${sequenceNumber}</td>
+                        <td>${fileName}</td>
+                        <td>获取中...</td>
+                        <td>${createDate}</td>
+                        <td>
+                            <button class="btn btn-sm btn-primary" onclick="playRecordingInPage('${fileName}', this)">播放</button>
+                            <a href="/recordings/${fileName}" class="btn btn-sm btn-secondary" download>下载</a>
+                        </td>
+                    `;
 
                 tableBody.appendChild(row);
 
@@ -1370,7 +1489,7 @@
             const xhr = new XMLHttpRequest();
             xhr.open('HEAD', `/recordings/${fileName}`, true);
 
-            xhr.onreadystatechange = function() {
+            xhr.onreadystatechange = function () {
                 if (xhr.readyState === 4) {
                     if (xhr.status === 200) {
                         // 获取Content-Length头
@@ -1581,34 +1700,34 @@
             // 倒序显示记录，最新的在最上面
             records.reverse().forEach((record, index) => {
                 const row = document.createElement("tr");
-                
+
                 // 序号列
                 const indexCell = document.createElement("td");
                 indexCell.textContent = index + 1;
                 row.appendChild(indexCell);
-                
+
                 // 时间列
                 const timeCell = document.createElement("td");
                 timeCell.textContent = record.timestamp || "未知时间";
                 row.appendChild(timeCell);
-                
+
                 // 内容列
                 const contentCell = document.createElement("td");
                 contentCell.textContent = record.text || "";
                 row.appendChild(contentCell);
-                
+
                 recordsList.appendChild(row);
             });
         }
 
         // 页面加载完成后初始化
-        document.addEventListener("DOMContentLoaded", function() {
+        document.addEventListener("DOMContentLoaded", function () {
             log("页面已加载");
             // 初始化SignalR连接
             initSignalR();
 
             // 切换到录音标签页时自动刷新录音列表
-            document.getElementById('recordings-tab').addEventListener('click', function() {
+            document.getElementById('recordings-tab').addEventListener('click', function () {
                 if (connection && connection.state === signalR.HubConnectionState.Connected) {
                     log("切换到录音标签页，自动刷新录音列表");
                     setTimeout(getRecentRecordings, 500);
@@ -1616,7 +1735,7 @@
             });
 
             // 切换到显示配置标签页时自动加载显示配置
-            document.getElementById('display-config-tab').addEventListener('click', function() {
+            document.getElementById('display-config-tab').addEventListener('click', function () {
                 if (connection && connection.state === signalR.HubConnectionState.Connected) {
                     log("切换到显示配置标签页，自动加载显示配置");
                     setTimeout(getDisplayConfig, 500);
@@ -1626,5 +1745,32 @@
             // 初始化显示配置默认值
             resetDisplayConfig();
         });
+
+        // 获取客户端列表
+        function getClientList() {
+            if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                showMessage("无法获取客户端列表：未连接到服务器", "warning");
+                return;
+            }
+
+            log("正在获取客户端列表...");
+
+            connection.invoke("GetClientList")
+                .then(() => {
+                    log("已成功发送获取客户端列表请求");
+                })
+                .catch(err => {
+                    log("获取客户端列表失败: " + err);
+                    showMessage("获取客户端列表失败: " + err, "danger");
+                });
+        }
+
+        // 切换到客户端标签页时自动刷新客户端列表
+        document.getElementById('clients-tab').addEventListener('click', function () {
+            if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                log("切换到客户端标签页，自动刷新客户端列表");
+                setTimeout(getClientList, 500);
+            }
+        });
     </script>
-} 
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/ShengShengBuXi/Pages/Index.cshtml b/ShengShengBuXi/Pages/Index.cshtml
index f3917a1..392ec0e 100644
--- a/ShengShengBuXi/Pages/Index.cshtml
+++ b/ShengShengBuXi/Pages/Index.cshtml
@@ -316,7 +316,7 @@
             // 整条文字渐显效果
             newP.animate(
                 { opacity: 1 }, 
-                2000, // 设置动画时长为2秒
+                3000, // 设置动画时长为2秒
                 'swing'
             );
             return true;
diff --git a/ShengShengBuXi/Pages/Monitor.cshtml b/ShengShengBuXi/Pages/Monitor.cshtml
index 2a0213b..8ed226c 100644
--- a/ShengShengBuXi/Pages/Monitor.cshtml
+++ b/ShengShengBuXi/Pages/Monitor.cshtml
@@ -5,7 +5,36 @@
 }
 
 <!-- 添加Bootstrap Icons库的引用 -->
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.5/font/bootstrap-icons.css">
+<link rel="stylesheet" href="~/css/bootstrap-icons.css">
+
+<style>
+  /* 覆盖Bootstrap默认的active类样式 */
+  #monitor-text-list .list-group-item.active {
+    background-color: transparent !important; /* 透明背景 */
+    color: inherit !important; /* 继承原有文字颜色 */
+    border-color: #dee2e6 !important; /* 使用默认边框颜色 */
+  }
+  
+  /* 如果需要，可以添加其他标识选中项的样式 */
+  #monitor-text-list .list-group-item.active {
+    border-left: 3px solid #28a745 !important; /* 添加左侧绿色边框作为选中标识 */
+    font-weight: bold; /* 文字加粗 */
+  }
+
+  /* 视频播放器样式 */
+  .audio-player-container {
+    display: none;
+    margin-top: 8px;
+    width: 100%;
+  }
+  
+  .audio-player {
+    width: 100%;
+    height: 40px;
+    background-color: #f8f9fa;
+    border-radius: 4px;
+  }
+</style>
 
 <div class="container-fluid">
     <!-- 头部区域 (100%, 20%) -->
@@ -21,49 +50,42 @@
                         <!-- 通话状态指示器 -->
                         <div class="d-flex align-items-center">
                             <div id="status-indicator" class="rounded-circle me-2"
-                                 style="width: 24px; height: 24px; background-color: red;"></div>
+                                style="width: 24px; height: 24px; background-color: red;"></div>
                             <span id="status-text" class="me-3">未检测到通话</span>
                         </div>
 
-                        <!-- 单选按钮组 - 隐藏自动识别显示选项 -->
-                        <div class="btn-group" role="group" style="display: none;">
-                            <input type="radio" class="btn-check" name="displayMode" id="displayMode0" value="0"
-                                   checked>
-                            <label class="btn btn-outline-primary" for="displayMode0">自动识别显示</label>
-
-                            <input type="radio" class="btn-check" name="displayMode" id="displayMode1" value="1">
-                            <label class="btn btn-outline-primary" for="displayMode1">手动处理显示</label>
+                        <!-- 预设句子类型控制 -->
+                        <div class="btn-group ms-3" role="group">
+                            <span class="me-2 d-flex align-items-center">大屏文本：</span>
+                            <input type="radio" class="btn-check" name="presetSentenceType" id="presetSentenceType0"
+                                value="0" checked onclick="updatePresetSentenceType(0)">
+                            <label class="btn btn-outline-primary" for="presetSentenceType0">文本1</label>
+                            <input type="radio" class="btn-check" name="presetSentenceType" id="presetSentenceType1"
+                                value="1" onclick="updatePresetSentenceType(1)">
+                            <label class="btn btn-outline-primary" for="presetSentenceType1">文本2</label>
                         </div>
 
-                        <!-- 音频传输开关 - 隐藏关闭音频传输选项 -->
+                        <!-- 控屏开关 - 优化样式 -->
                         <div class="btn-group ms-3" role="group">
+                            <span class="me-2 d-flex align-items-center">控屏模式：</span>
+                            <input type="radio" class="btn-check" name="screenControl" id="screenControlAuto" value="0"
+                                checked>
+                            <label class="btn btn-outline-primary" for="screenControlAuto">自动</label>
+                            <input type="radio" class="btn-check" name="screenControl" id="screenControlManual"
+                                value="1">
+                            <label class="btn btn-outline-primary" for="screenControlManual">手动</label>
+                        </div>
+
+                        <!-- 音频传输开关 - 隐藏 -->
+                        <div class="btn-group ms-3" role="group" style="display: none;">
                             <input type="radio" class="btn-check" name="audioStreaming" id="audioStreaming1" value="1"
-                                   checked>
+                                checked>
                             <label class="btn btn-outline-success" for="audioStreaming1">开启音频传输</label>
 
                             <input type="radio" class="btn-check" name="audioStreaming" id="audioStreaming0" value="0"
-                                   style="display: none;">
+                                style="display: none;">
                             <label class="btn btn-outline-danger" for="audioStreaming0"
-                                   style="display: none;">关闭音频传输</label>
-
-                            <!-- 音量控制滑块 -->
-                            <div class="ms-3 d-flex align-items-center">
-                                <label for="volumeControl" class="me-2"><i class="bi bi-volume-up"></i></label>
-                                <input type="range" class="form-range" min="0" max="1" step="0.1" value="1.0"
-                                       id="volumeControl" style="width: 100px;">
-                            </div>
-                        </div>
-
-                        <!-- 控屏开关 -->
-                        <div class="btn-group ms-3" role="group">
-                            控评开关：
-                            <input type="radio" class="btn-check" name="screenControl" id="screenControlAuto" value="0"
-                                   checked>
-                            <label class="btn btn-outline-primary" for="screenControlAuto">自动</label>
-
-                            <input type="radio" class="btn-check" name="screenControl" id="screenControlManual"
-                                   value="1">
-                            <label class="btn btn-outline-primary" for="screenControlManual">手动</label>
+                                style="display: none;">关闭音频传输</label>
                         </div>
                     </div>
                 </div>
@@ -76,11 +98,11 @@
             <div class="col-3">
                 <div class="card h-100">
                     <div class="card-header">
-                        <h5 class="mb-0">监控文本列表</h5>
+                        <h5 class="mb-0">语音列表</h5>
                     </div>
                     <div class="card-body p-0">
                         <div id="monitor-text-list" class="list-group list-group-flush"
-                             style="max-height: 75vh; overflow-y: auto;">
+                            style="max-height: 75vh; overflow-y: auto;">
                             <!-- 文本列表内容将通过JS动态填充 -->
                             <div class="text-center text-muted p-3">加载中...</div>
                         </div>
@@ -115,12 +137,12 @@
                                 <div class="card h-100">
                                     <div class="card-header">
                                         <h5 class="mb-0">
-                                            文本编辑 <span style="color:#6c757d;font-size:12px;">(最多输入100个文字)</span>
+                                            文本编辑
                                         </h5>
                                     </div>
                                     <div class="card-body">
-                                        <textarea id="text-input" class="form-control h-100" placeholder="请输入要显示的文本..."
-                                                  maxlength="100"></textarea>
+                                        <textarea id="text-input" class="form-control h-100"
+                                            placeholder="请输入要显示的文本..."></textarea>
 
                                     </div>
                                 </div>
@@ -131,12 +153,12 @@
                                 <div class="card h-100">
                                     <div class="card-body d-flex justify-content-center align-items-center">
                                         <button id="add-text-btn" class="btn btn-primary me-3" data-bs-toggle="tooltip"
-                                                title="将文本添加到显示队列，并显示在大屏上" onclick="addDisplayText()">
+                                            title="将文本添加到显示队列，并显示在大屏上" onclick="addDisplayText()">
                                             <i class="bi bi-plus-circle"></i> 显示到大屏
                                         </button>
                                         <button id="add-and-remove-btn" class="btn btn-warning" data-bs-toggle="tooltip"
-                                                title="将文本添加到显示队列，并从监控列表中移除当前选中项" onclick="addDisplayTextAndRemoveMonitor()"
-                                                style="display: none;">
+                                            title="将文本添加到显示队列，并从监控列表中移除当前选中项" onclick="addDisplayTextAndRemoveMonitor()"
+                                            style="display: none;">
                                             <i class="bi bi-arrow-right-circle"></i> 添加并移除
                                         </button>
                                     </div>
@@ -160,7 +182,7 @@
                     </div>
                     <div class="card-body p-0">
                         <div id="display-text-list" class="list-group list-group-flush"
-                             style="max-height: 75vh; overflow-y: auto;">
+                            style="max-height: 75vh; overflow-y: auto;">
                             <!-- 文本列表内容将通过JS动态填充 -->
                             <div class="text-center text-muted p-3">加载中...</div>
                         </div>
@@ -169,6 +191,8 @@
             </div>
         </div>
 
+
+
         <!-- 调试区域 (底部) -->
         <div class="row mt-3">
             <div class="col-12">
@@ -193,7 +217,7 @@
 
     <!-- 来电确认对话框 -->
     <div class="modal fade" id="callConfirmDialog" tabindex="-1" aria-labelledby="callConfirmDialogLabel"
-         aria-hidden="true" data-bs-backdrop="static" data-bs-keyboard="false">
+        aria-hidden="true" data-bs-backdrop="static" data-bs-keyboard="false">
         <div class="modal-dialog modal-dialog-centered">
             <div class="modal-content">
                 <div class="modal-header bg-primary text-white">
@@ -217,36 +241,7 @@
         </div>
     </div>
 
-    <div class="card mb-3">
-        <div class="card-header">
-            <h5>音频控制</h5>
-        </div>
-        <div class="card-body">
-            <div class="form-check form-switch mb-3">
-                <input class="form-check-input" type="checkbox" id="audioStreamToggle">
-                <label class="form-check-label" for="audioStreamToggle">音频流接收</label>
-            </div>
-
-            <!-- 音量控制 -->
-            <div class="mb-3">
-                <label for="volumeSlider" class="form-label">音量控制 <span id="volumeDisplay">100%</span></label>
-                <div class="d-flex align-items-center">
-                    <i class="bi bi-volume-down me-2"></i>
-                    <input type="range" class="form-range flex-grow-1" id="volumeSlider" min="0" max="100" value="100">
-                    <i class="bi bi-volume-up ms-2"></i>
-                </div>
-                <small class="text-muted">音量已增强3倍，可按需调整</small>
-            </div>
-
-            <div class="mt-3" id="callStatus">
-                <div class="alert alert-secondary">
-                    未检测到通话
-                </div>
-            </div>
-        </div>
-    </div>
-
-    @section Scripts {
+@section Scripts {
         <script src="~/lib/microsoft-signalr/signalr.min.js"></script>
 
         <script src="https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js"></script>
@@ -334,9 +329,9 @@
                 const alert = document.createElement("div");
                 alert.className = `alert alert-${type} alert-dismissible fade show`;
                 alert.innerHTML = `
-                                                        ${message}
-                                                        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
-                                                    `;
+                                                                                            ${message}
+                                                                                            <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+                                                                                        `;
                 messageArea.appendChild(alert);
 
                 // 自动移除
@@ -434,6 +429,9 @@
                         // 获取当前控屏设置
                         getServerScreenControlSetting();
 
+                        // 获取当前预设句子类型设置
+                        getServerPresetSentenceTypeSetting();
+
                         // 设置定时刷新显示列表
                         if (refreshDisplayInterval) {
                             clearInterval(refreshDisplayInterval);
@@ -497,7 +495,7 @@
                     showFinalTextResult(result);
 
                     // 同时添加到监控列表的顶部（如果不存在于列表中）
-                    addToMonitorList(result);
+                    //  addToMonitorList(result);
                 });
 
                 // 显示模式更新消息
@@ -517,13 +515,32 @@
                     }
                 });
 
+                // 通话状态改变
+                connection.on("CallStateChanged", (isActive) => {
+                    updateCallStatus(isActive);
+                });
                 // 接收实时音频数据
                 connection.on("ReceiveAudioData", (audioData) => {
                     if (!isActiveShow) {
-                        updateCallStatus(true);
+                        // 添加音频流持续检测逻辑
+                        if (!window.audioStreamStartTime) {
+                            // 设置音频流开始接收时间
+                            window.audioStreamStartTime = Date.now();
+                            log("检测到音频流，开始计时");
+                        } else {
+                            // 检查是否超过5秒
+                            const elapsedTime = Date.now() - window.audioStreamStartTime;
+                            if (elapsedTime > 5000) {
+                                log(`音频流持续时间 ${(elapsedTime / 1000).toFixed(1)}秒，触发通话状态更新`);
+                                window.audioStreamStartTime = null; // 重置计时器
+                                updateCallStatus(true);
+                            }
+                        }
                         return;
+                    } else {
+                        // 重置音频流计时器
+                        window.audioStreamStartTime = null;
                     }
-
                 });
 
                 // 音频流设置更新消息
@@ -568,21 +585,33 @@
                     // 当检测到新通话时，先显示确认对话框
                     const confirmDialog = new bootstrap.Modal(document.getElementById('callConfirmDialog'));
                     confirmDialog.show();
-                    enterRoom();
+
                     return; // 等待用户确认后再继续处理
                 } else {
                     const indicator = document.getElementById("status-indicator");
                     const statusText = document.getElementById("status-text");
                     indicator.style.backgroundColor = "red";
                     statusText.textContent = "未检测到通话";
-
+                    leaveRoom();
                     // 如果确认对话框还在显示（用户未点击接听），则自动关闭
+                    // const confirmDialog = new bootstrap.Modal(document.getElementById('callConfirmDialog'));
                     const confirmDialog = bootstrap.Modal.getInstance(document.getElementById('callConfirmDialog'));
                     if (confirmDialog) {
                         confirmDialog.hide();
-                        exitRoom();
+                        // 添加以下代码来移除背景遮罩
+                        setTimeout(() => {
+                            const backdrop = document.querySelector('.modal-backdrop');
+                            if (backdrop) {
+                                backdrop.remove();
+                            }
+                            // 或者还需要移除body上的class
+                            document.body.classList.remove('modal-open');
+                            document.body.style.overflow = '';
+                            document.body.style.paddingRight = '';
+                        }, 150); // 给一点延迟，确保模态框动画完成
                         log("通话已结束，自动关闭确认对话框");
                     }
+
                 }
 
                 // 有新通话时刷新监控列表
@@ -596,36 +625,12 @@
                 indicator.style.backgroundColor = "green";
                 statusText.textContent = "正在通话中";
                 callInProgress = true;
-
-                // 初始化音频上下文（如果需要且启用了音频流）
-                if (isAudioStreamEnabled) {
-                    // 如果存在音频上下文，则先尝试关闭，然后重新创建
-                    if (audioContext) {
-                        log("重置音频上下文以确保新的通话正常播放");
-                        try {
-                            // 释放旧的增益节点
-                            if (audioGainNode) {
-                                audioGainNode.disconnect();
-                                audioGainNode = null;
-                            }
-                            // 关闭旧的音频上下文
-                            audioContext.close().catch(e => log("关闭音频上下文失败: " + e));
-                            audioContext = null;
-                        } catch (e) {
-                            log("重置音频上下文失败: " + e);
-                        }
-                    }
-
-                    // 创建新的音频上下文
-                    initAudioContext();
-                }
-
+                enterRoom();
                 // 关闭确认对话框
                 const confirmDialog = bootstrap.Modal.getInstance(document.getElementById('callConfirmDialog'));
                 if (confirmDialog) {
                     confirmDialog.hide();
                 }
-
                 // 刷新监控列表
                 loadMonitorTextList();
             }
@@ -668,7 +673,6 @@
                     const listItem = document.createElement("div");
                     listItem.className = "list-group-item";
                     listItem.dataset.id = item.id;
-                    // 存储原始文本，用于点击后显示
                     listItem.dataset.fullText = item.text || item.completedText || "无文本内容";
 
                     // 添加点击事件
@@ -699,23 +703,30 @@
                     // 截取前10个字符，若不足10个则全部显示
                     const shortText = text.length > 10 ? text.substring(0, 10) : text;
 
+                    // 添加HTML内容，包括视频播放控件
                     listItem.innerHTML = `
-                                                                    <div class="d-flex justify-content-between align-items-start mb-1">
-                                                                        <small class="text-muted">【${shortText}】</small>
-                                                                        <div class="btn-group btn-group-sm">
-                                                                            <button class="btn btn-outline-primary btn-sm" onclick="playAudio('${item.recordingPath || ''}', this)">
-                                                                                <i class="bi bi-play-fill"></i>
-                                                                            </button>
-                                                                            <button class="btn btn-outline-secondary btn-sm" onclick="downloadRecording('${item.recordingPath || ''}')">
-                                                                                <i class="bi bi-download"></i>
-                                                                            </button>
-                                                                            <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${item.id}')">
-                                                                                <i class="bi bi-trash"></i>
-                                                                            </button>
-                                                                        </div>
-                                                                    </div>
-                                                                    <div>${formattedDate}</div>
-                                                                `;
+                        <div class="d-flex justify-content-between align-items-start mb-1">
+                            <small class="text-muted">【${shortText}】</small>
+                            <div class="btn-group btn-group-sm">
+                                <button class="btn btn-outline-primary btn-sm" onclick="toggleAudioPlayer('${item.id}', '${item.recordingPath || ''}')">
+                                    <i class="bi bi-play-fill"></i>
+                                </button>
+                                <button class="btn btn-outline-secondary btn-sm" onclick="downloadRecording('${item.recordingPath || ''}')">
+                                    <i class="bi bi-download"></i>
+                                </button>
+                                <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${item.id}')">
+                                    <i class="bi bi-trash"></i>
+                                </button>
+                            </div>
+                        </div>
+                        <div>${formattedDate}</div>
+                        <div id="audio-container-${item.id}" class="audio-player-container">
+                            <video id="audio-player-${item.id}" class="audio-player" controls>
+                                <source src="${item.recordingPath || ''}" type="audio/wav">
+                                您的浏览器不支持视频标签。
+                            </video>
+                        </div>
+                    `;
 
                     container.appendChild(listItem);
                 });
@@ -764,6 +775,7 @@
 
                 // 如果是当前正在播放的音频
                 if (currentAudio && currentPlayButton === button) {
+                    currentAudio.volume = 1;
                     if (currentAudio.paused) {
                         // 如果当前是暂停状态，则继续播放
                         log(`继续播放音频: ${path}`);
@@ -921,11 +933,11 @@
                     const shortText = text.length > 5 ? text.substring(0, 5) : text;
 
                     listItem.innerHTML = `
-                                                                    <div class="mb-1">
-                                                                        <small class="text-muted">${formattedDate}</small>
-                                                                    </div>
-                                                                    <div>【${shortText}】</div>
-                                                                `;
+                                                                                                        <div class="mb-1">
+                                                                                                            <small class="text-muted">${formattedDate}</small>
+                                                                                                        </div>
+                                                                                                        <div>【${shortText}】</div>
+                                                                                                    `;
 
                     container.appendChild(listItem);
                 });
@@ -1113,6 +1125,10 @@
                 document.getElementById("audioStreaming1").checked = true;
                 isAudioStreamEnabled = true;
 
+                // 初始化UI和事件
+                initUI();
+
+
             });
 
             // 页面卸载前清理资源
@@ -1135,9 +1151,6 @@
 
                 // 确保值在有效范围内(0或1)
                 if (displayType === 0 || displayType === 1) {
-                    // 更新单选按钮状态
-                    document.getElementById(`displayMode${displayType}`).checked = true;
-
                     log(`UI显示模式已更新为: ${displayType === 0 ? "识别立即显示" : "手动显示"}`);
                 }
             }
@@ -1172,7 +1185,7 @@
                 displayedText.textContent = text;
 
                 // 同时将文本填入输入框
-                document.getElementById("text-input").value = text;
+                // document.getElementById("text-input").value = text;
 
                 // 显示文本编辑区域和按钮区域
                 document.getElementById("input-text-area").style.display = "block";
@@ -1486,243 +1499,8 @@
                 }
             }
 
-            // 播放实时音频 - 适应新格式
-            function playRealTimeAudio(audioPacket) {
-                if (!audioContext || !isAudioStreamEnabled || !callInProgress) return;
 
-                try {
-                    // 解析音频元数据和数据
-                    const { format, sampleRate, channels, data } = audioPacket;
 
-                    // 确保格式正确
-                    if (!format || !data) {
-                        log("音频格式或数据无效");
-                        return;
-                    }
-
-                    log(`接收到音频数据: 格式=${format}, 采样率=${sampleRate}, 声道=${channels}, 数据长度=${Array.isArray(data) ? data.length : '未知'}`);
-
-                    // 根据不同的音频格式处理
-                    if (format === "WAV") {
-                        // 处理WAV格式数据 - 异步解码
-                        processWavData(data, sampleRate, channels)
-                            .then(audioBuffer => {
-                                if (audioBuffer) {
-                                    playAudioBuffer(audioBuffer);
-                                } else {
-                                    log("无法创建WAV音频缓冲区");
-                                }
-                            })
-                            .catch(err => {
-                                log("WAV处理错误: " + err);
-                            });
-                    } else if (format === "16bit_PCM") {
-                        // 处理PCM格式数据 - 同步处理
-                        const audioBuffer = processPcmData(data, sampleRate, channels);
-                        if (audioBuffer) {
-                            playAudioBuffer(audioBuffer);
-                        } else {
-                            log("无法创建PCM音频缓冲区");
-                        }
-                    } else {
-                        log("不支持的音频格式: " + format);
-                    }
-                } catch (e) {
-                    log("处理实时音频失败: " + e);
-                }
-            }
-
-            // 播放音频缓冲区
-            function playAudioBuffer(audioBuffer) {
-                // 确保音频上下文活跃
-                if (audioContext.state === 'suspended') {
-                    try {
-                        audioContext.resume();
-                    } catch (e) {
-                        log("恢复音频上下文失败: " + e);
-                        return;
-                    }
-                }
-
-                // 创建音频源并连接
-                const source = audioContext.createBufferSource();
-                source.buffer = audioBuffer;
-
-                // 应用音量控制
-                source.connect(audioGainNode);
-                if (audioGainNode) {
-                    audioGainNode.gain.value = currentVolume * volumeBoost;
-                }
-
-                // 立即播放
-                source.start(0);
-                log("开始播放音频");
-            }
-
-            // 处理WAV格式的数据 - 返回Promise
-            function processWavData(data, sampleRate, channels) {
-                return new Promise((resolve, reject) => {
-                    try {
-                        // 确保音频上下文存在
-                        if (!audioContext || audioContext.state === 'closed') {
-                            initAudioContext();
-                            if (!audioContext) {
-                                reject(new Error("无法初始化音频上下文"));
-                                return;
-                            }
-                        }
-
-                        // 将数据转换为ArrayBuffer
-                        let arrayBuffer;
-                        if (data instanceof Uint8Array) {
-                            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-                        } else if (Array.isArray(data)) {
-                            // 转换数组为Uint8Array
-                            const uint8Array = new Uint8Array(data);
-                            arrayBuffer = uint8Array.buffer;
-                        } else if (typeof data === 'string') {
-                            // 处理Base64编码
-                            try {
-                                const base64Str = data.trim().replace(/^data:[^;]+;base64,/, '');
-                                const binary = atob(base64Str);
-                                const uint8Array = new Uint8Array(binary.length);
-                                for (let i = 0; i < binary.length; i++) {
-                                    uint8Array[i] = binary.charCodeAt(i);
-                                }
-                                arrayBuffer = uint8Array.buffer;
-                            } catch (e) {
-                                log("WAV数据Base64解码失败: " + e);
-                                reject(e);
-                                return;
-                            }
-                        } else if (data.buffer) {
-                            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-                        } else {
-                            const error = new Error("无法处理的WAV数据类型");
-                            log(error.message);
-                            reject(error);
-                            return;
-                        }
-
-                        // 使用Web Audio API解码音频
-                        audioContext.decodeAudioData(
-                            arrayBuffer,
-                            (buffer) => {
-                                log("WAV数据解码成功, 时长: " + buffer.duration.toFixed(2) + "秒");
-                                resolve(buffer);
-                            },
-                            (err) => {
-                                log("解码WAV数据失败: " + err);
-                                reject(err);
-                            }
-                        );
-                    } catch (e) {
-                        log("处理WAV数据失败: " + e);
-                        reject(e);
-                    }
-                });
-            }
-
-            // 处理PCM格式的数据
-            function processPcmData(data, sampleRate, channels) {
-                try {
-                    // 确保音频上下文存在
-                    if (!audioContext || audioContext.state === 'closed') {
-                        initAudioContext();
-                        if (!audioContext) return null;
-                    }
-
-                    // 转换数据为适合的格式
-                    let pcmData;
-                    if (data instanceof Uint8Array) {
-                        pcmData = data;
-                    } else if (Array.isArray(data)) {
-                        pcmData = new Uint8Array(data);
-                    } else if (typeof data === 'object' && data.buffer) {
-                        pcmData = new Uint8Array(data.buffer);
-                    } else if (typeof data === 'string') {
-                        try {
-                            // 处理Base64编码
-                            const base64Str = data.trim().replace(/^data:[^;]+;base64,/, '');
-                            const binary = atob(base64Str);
-                            pcmData = new Uint8Array(binary.length);
-                            for (let i = 0; i < binary.length; i++) {
-                                pcmData[i] = binary.charCodeAt(i);
-                            }
-                        } catch (e) {
-                            log("PCM数据Base64解码失败: " + e);
-                            return null;
-                        }
-                    } else {
-                        log("不支持的PCM数据类型");
-                        return null;
-                    }
-
-                    // 确保有效的数据
-                    if (!pcmData || pcmData.length < 2) {
-                        log("PCM数据无效或太短");
-                        return null;
-                    }
-
-                    // 确保数据长度是偶数（16位PCM）
-                    const validLength = Math.floor(pcmData.length / 2) * 2;
-                    if (validLength < pcmData.length) {
-                        pcmData = pcmData.slice(0, validLength);
-                    }
-
-                    try {
-                        // 从Uint8Array创建Int16Array视图
-                        let int16Data;
-
-                        try {
-                            // 创建DataView以便正确解析16位整数
-                            const dataView = new DataView(pcmData.buffer, pcmData.byteOffset, pcmData.byteLength);
-                            int16Data = new Int16Array(pcmData.length / 2);
-
-                            // 从小端字节序读取16位整数
-                            for (let i = 0; i < pcmData.length; i += 2) {
-                                if (i + 1 < pcmData.length) {
-                                    int16Data[i / 2] = dataView.getInt16(i, true); // true表示小端字节序
-                                }
-                            }
-                        } catch (e) {
-                            log("创建Int16Array失败: " + e);
-
-                            // 备用方法
-                            const newBuffer = new ArrayBuffer(pcmData.length);
-                            const newView = new Uint8Array(newBuffer);
-                            newView.set(pcmData);
-                            const dataView = new DataView(newBuffer);
-
-                            int16Data = new Int16Array(pcmData.length / 2);
-                            for (let i = 0; i < pcmData.length; i += 2) {
-                                if (i + 1 < pcmData.length) {
-                                    int16Data[i / 2] = dataView.getInt16(i, true);
-                                }
-                            }
-                        }
-
-                        // 创建音频缓冲区，使用实际采样率
-                        const audioSampleRate = sampleRate || audioContext.sampleRate;
-                        const buffer = audioContext.createBuffer(channels || 1, int16Data.length, audioSampleRate);
-
-                        // 将Int16数据转换为Float32数据并存入缓冲区
-                        const channelData = buffer.getChannelData(0);
-                        for (let i = 0; i < int16Data.length; i++) {
-                            // 将Int16转换为-1.0到1.0的Float32
-                            channelData[i] = Math.max(-1, Math.min(1, int16Data[i] / 32768.0));
-                        }
-
-                        return buffer;
-                    } catch (e) {
-                        log("PCM数据处理失败: " + e);
-                        return null;
-                    }
-                } catch (e) {
-                    log("处理PCM数据失败: " + e);
-                    return null;
-                }
-            }
 
             // 显示实时语音识别结果
             function showRealtimeTextResult(text) {
@@ -1747,9 +1525,6 @@
                 const displayedText = document.getElementById("displayed-text");
                 displayedText.innerHTML = `<span class="final-text">${text}</span>`;
 
-                // 同时将文本填入输入框，便于编辑
-                // document.getElementById("text-input").value = text;
-
                 log("显示最终语音识别结果");
             }
 
@@ -1802,16 +1577,16 @@
                 const shortText = text.length > 10 ? text.substring(0, 10) : text;
 
                 listItem.innerHTML = `
-                                                        <div class="d-flex justify-content-between align-items-start mb-1">
-                                                            <small class="text-muted">【${shortText}】</small>
-                                                            <div class="btn-group btn-group-sm">
-                                                                <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${listItem.dataset.id}')">
-                                                                    <i class="bi bi-trash"></i>
-                                                                </button>
-                                                            </div>
-                                                        </div>
-                                                        <div>${formattedDate} (本地)</div>
-                                                    `;
+                                                                                            <div class="d-flex justify-content-between align-items-start mb-1">
+                                                                                                <small class="text-muted">【${shortText}】</small>
+                                                                                                <div class="btn-group btn-group-sm">
+                                                                                                    <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${listItem.dataset.id}')">
+                                                                                                        <i class="bi bi-trash"></i>
+                                                                                                    </button>
+                                                                                                </div>
+                                                                                            </div>
+                                                                                            <div>${formattedDate} (本地)</div>
+                                                                                        `;
 
                 // 添加到列表顶部
                 if (container.firstChild) {
@@ -1852,5 +1627,230 @@
                         updateScreenControlUI(false);
                     });
             }
+
+            // 初始化UI和事件
+            function initUI() {
+                // 查询当前选择的模式
+                if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                    // 获取当前控屏设置
+                    getServerScreenControlSetting();
+
+                    // 获取当前音频流设置
+                    getServerAudioStreamingSetting();
+
+                    // 获取当前预设句子类型设置
+                    getServerPresetSentenceTypeSetting();
+                }
+
+                // 设置工具提示
+                var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+                tooltipTriggerList.map(function (tooltipTriggerEl) {
+                    return new bootstrap.Tooltip(tooltipTriggerEl);
+                });
+            }
+
+            // 获取服务器当前预设句子类型设置
+            function getServerPresetSentenceTypeSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取预设句子类型设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前预设句子类型设置...");
+
+                connection.invoke("GetPresetSentenceType")
+                    .then(type => {
+                        log(`获取到服务器当前预设句子类型设置: ${type}`);
+                        updatePresetSentenceTypeUI(type);
+                    })
+                    .catch(err => {
+                        log("获取预设句子类型设置失败: " + err);
+                    });
+            }
+
+            // 更新预设句子类型UI
+            function updatePresetSentenceTypeUI(type) {
+                // 更新单选按钮状态
+                document.getElementById(`presetSentenceType${type}`).checked = true;
+                log(`UI预设句子类型设置已更新为: ${type}`);
+            }
+
+            // 更新预设句子类型
+            function updatePresetSentenceType(type) {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法更新预设句子类型：未连接到服务器", "danger");
+                    log("更新预设句子类型失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在更新预设句子类型: ${type}`);
+
+                connection.invoke("UpdatePresetSentenceType", type)
+                    .then(result => {
+                        if (result) {
+                            log("预设句子类型更新成功");
+                            showMessage(`预设句子类型已更新为: ${type === 0 ? '默认预设句子' : '预设句子2'}`, "success");
+                        } else {
+                            log("预设句子类型更新失败");
+                            showMessage("预设句子类型更新失败", "danger");
+                        }
+                    })
+                    .catch(err => {
+                        log(`更新预设句子类型失败: ${err}`);
+                        showMessage("更新预设句子类型失败", "danger");
+                    });
+            }
+
+            // 添加预设句子
+            function addPresetSentence() {
+                const sentenceInput = document.getElementById("presetSentenceInput");
+                const text = sentenceInput.value.trim();
+
+                if (!text) {
+                    showMessage("请输入要添加的预设句子", "warning");
+                    log("添加预设句子失败：未输入文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加预设句子：未连接到服务器", "danger");
+                    log("添加预设句子失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在添加预设句子: ${text}`);
+
+                connection.invoke("AddPresetSentence", text)
+                    .then(result => {
+                        if (result) {
+                            log("预设句子添加成功");
+                            showMessage("预设句子已添加", "success");
+                            // 清空输入框
+                            sentenceInput.value = "";
+                        } else {
+                            log("预设句子添加失败");
+                            showMessage("预设句子添加失败", "danger");
+                        }
+                    })
+                    .catch(err => {
+                        log(`添加预设句子失败: ${err}`);
+                        showMessage("添加预设句子失败", "danger");
+                    });
+            }
+
+            // 添加监听器：预设句子类型已更改
+            function setupPresetSentenceTypeListeners() {
+                connection.on("PresetSentenceTypeChanged", function (type) {
+                    log(`收到预设句子类型更改通知: ${type}`);
+                    updatePresetSentenceTypeUI(type);
+                });
+
+                connection.on("PresetSentencesUpdated", function () {
+                    log("收到预设句子更新通知");
+                    showMessage("预设句子列表已更新", "info");
+                });
+            }
+
+            // 切换音频播放器显示/隐藏
+            function toggleAudioPlayer(id, path) {
+                if (!path) {
+                    showMessage("无可播放的录音", "warning");
+                    return;
+                }
+                
+                // 获取容器和播放器元素
+                const container = document.getElementById(`audio-container-${id}`);
+                const player = document.getElementById(`audio-player-${id}`);
+                const button = event.currentTarget;
+                const buttonIcon = button.querySelector('i');
+                
+                // 切换显示状态
+                if (container.style.display === "none" || !container.style.display) {
+                    // 隐藏其他所有播放器
+                    document.querySelectorAll('.audio-player-container').forEach(el => {
+                        el.style.display = "none";
+                    });
+                    
+                    // 显示当前播放器
+                    container.style.display = "block";
+                    
+                    // 播放音频
+                    player.play();
+                    buttonIcon.className = "bi bi-pause-fill";
+                } else {
+                    // 如果已显示，则切换播放/暂停状态
+                    if (player.paused) {
+                        player.play();
+                        buttonIcon.className = "bi bi-pause-fill";
+                    } else {
+                        player.pause();
+                        buttonIcon.className = "bi bi-play-fill";
+                    }
+                }
+                
+                // 播放结束时更新按钮图标
+                player.onended = function() {
+                    buttonIcon.className = "bi bi-play-fill";
+                };
+            }
+
+            // 启动连接
+            async function start() {
+                try {
+                    if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                        log("已经连接到Hub，无需重新连接");
+                        return;
+                    }
+                    debugger
+                    if (!connection) {
+                        log("初始化SignalR连接...");
+
+                        // 创建连接
+                        connection = new signalR.HubConnectionBuilder()
+                            .withUrl("/audiohub")
+                            .withAutomaticReconnect()
+                            .build();
+
+                        // 设置连接事件监听
+                        setupConnectionEventHandlers();
+
+                        // 设置消息接收处理器
+                        setupMessageHandlers();
+
+                        // 设置控屏设置变更监听器
+                        setupScreenControlListeners();
+
+                        // 设置音频流设置变更监听器
+                        setupAudioStreamingListeners();
+
+                        // 设置预设句子类型变更监听器
+                        setupPresetSentenceTypeListeners();
+                    }
+
+                    log("正在连接到Hub...");
+                    await connection.start();
+                    log("成功连接到Hub");
+
+                    // 注册为监控客户端
+                    await connection.invoke("RegisterClient", "monitor");
+                    log("已注册为监控客户端");
+
+                    // 加载文本列表
+                    loadTextLists();
+
+                    // 初始化音频上下文
+                    initAudioContext();
+
+                    // 启用实时音频流
+                    isAudioStreamEnabled = true;
+
+                    // 初始化UI和事件
+                    initUI();
+
+                } catch (err) {
+                    log(`连接失败：${err}`);
+                    setTimeout(start, 5000); // 5秒后重试
+                }
+            }
         </script>
-    }
+}
diff --git a/ShengShengBuXi/config/display.json b/ShengShengBuXi/config/display.json
index 7590a0b..ca0fa74 100644
--- a/ShengShengBuXi/config/display.json
+++ b/ShengShengBuXi/config/display.json
@@ -8,10 +8,10 @@
     "fontSize": "40px",
     "fontWeight": "bolder",
     "fontStyle": "italic",
-    "typewriterSpeed": 18000,
+    "typewriterSpeed": 33000,
     "fadeChars": 1,
-    "fadeStepTime": 3000,
-    "fadeDelayFactor": 0.20
+    "fadeStepTime": 5000,
+    "fadeDelayFactor": 0.15
   },
   "waterEffect": {
     "enabled": true,
diff --git a/ShengShengBuXi/config/monitor_text_queue.json b/ShengShengBuXi/config/monitor_text_queue.json
new file mode 100644
index 0000000..5cbba67
--- /dev/null
+++ b/ShengShengBuXi/config/monitor_text_queue.json
@@ -0,0 +1,62 @@
+[
+  {
+    "Id": "963cc0c4-2acf-4f00-9c13-119ef85a66f1",
+    "Text": "就因为一条互联网的条件叠加恶意营销的影响",
+    "Timestamp": "2025-03-30T00:19:24.4648136+08:00",
+    "IsRealUser": true,
+    "RecognitionId": "7obT5sL_slaaK3cdqNTq-w",
+    "Priority": 10,
+    "IsProcessed": false,
+    "CompletedText": null,
+    "RecordingPath": "D:\\CodeManage\\ShengShengBuXi\\ShengShengBuXi\\ShengShengBuXi\\recordings\\recording_20250330_001916.wav",
+    "TextFilePath": "D:\\CodeManage\\ShengShengBuXi\\ShengShengBuXi\\ShengShengBuXi\\recordings\\recording_20250330_001916.txt"
+  },
+  {
+    "Id": "ea36edcc-d169-4b1f-971e-c48239c779a3",
+    "Text": "鸡精的AB视背景，然后是盐，就是加强的谷氨酸钠，再加钠，最后还会再加上核苷酸",
+    "Timestamp": "2025-03-30T00:17:12.5192552+08:00",
+    "IsRealUser": true,
+    "RecognitionId": "5QB3lEX9vbLEOgkiiy2FTw",
+    "Priority": 10,
+    "IsProcessed": false,
+    "CompletedText": null,
+    "RecordingPath": "/recordings/recording_20250330_001701.wav",
+    "TextFilePath": "/texts/recording_20250330_001701.txt"
+  },
+  {
+    "Id": "b12d7083-057f-4001-b1bc-1dacd576a4a7",
+    "Text": "不是，而是你的\n我期待的不是月，而是和你的遇见。我期待烟花满天，我可以\n永远靠在你左肩，我期待\n不是一句抱歉\n失恋\n屋檐梨花\n再见",
+    "Timestamp": "2025-03-29T23:51:57.5244072+08:00",
+    "IsRealUser": true,
+    "RecognitionId": "RRr0moprCn6UBwu80K0orQ",
+    "Priority": 10,
+    "IsProcessed": false,
+    "CompletedText": null,
+    "RecordingPath": "/recordings/recording_20250329_235110.wav",
+    "TextFilePath": "/texts/recording_20250329_235110.txt"
+  },
+  {
+    "Id": "f6bbc349-29e5-48fe-a97c-a16dfd65cc90",
+    "Text": "播某濒临破产，老板儿子含泪直播，近一人观看，这家微星企业回应了，这是谣言，公司很火爆，我们现在挺好的，这是谣传，濒临破产这个事儿之前确实是真的国产味精曾经的王者某花，如何从山顶跌下悬崖，又如何起死回生呢？省油的版本是，这是一个极度典型的曾经一个农业加工类的巨无霸国产品牌，就因为一条互联网的谣言叠加恶意营销的影响，一度受挫，濒临风雨\n而他的重新复苏契机是2023年底的一支眉笔，他们家在直播间顺势推出了79块钱5斤半的味精套餐呢，更是因为互联网客户信息，从当年妖言惑众，劣币驱逐良币的时代，逐渐向",
+    "Timestamp": "2025-03-30T00:15:32.2187442+08:00",
+    "IsRealUser": true,
+    "RecognitionId": "Eh6MPMq46zQBwUoXa9-twg",
+    "Priority": 10,
+    "IsProcessed": false,
+    "CompletedText": null,
+    "RecordingPath": "/recordings/recording_20250330_001442.wav",
+    "TextFilePath": "/texts/recording_20250330_001442.txt"
+  },
+  {
+    "Id": "ab9742d6-69fb-4754-b3aa-b47cd311520d",
+    "Text": "学的武和表演相衡的时代来说，悬崖到当年的谣言是什么？还不就是什么胃镜致癌、胃经秃头、胃经不孕，这些信息在2000年左右并不是他与此同时呢，以基金为代表的一些新的纤维添加剂疯狂的占据了未经失去的阵地。巧的是在1999年发生了一个事儿，某家鸟类的家的公司收购了一家国产基金品牌\n是日本的饭，某人有一天喝了一碗海带汤，觉得很鲜，就到实验室里一顿提取，然后取名为未知素，成分就是谷氨酸钠。拆解出来呢。谷氨酸是天然食物蛋白质里普遍存在的一种氨基酸啊，但它平常是没有什么味道的，比如说每100g的鸡肉的蛋白质里头就有3.6g的谷氨酸。但是，你直接吃鸡肉好像并不咋鲜。你熬鸡汤的时候才泄，那是谷氨酸游离出来。这个时候再加上一点儿盐，于是就成了能被我们人体感知的纤维。盐的主要成分就是na嘛，所以谷氨酸钠为什么先就是这个道理。那为啥说是农业加工企业呢？我们看一眼味精的原料表上面儿俩字儿，小麦，当然几十年前还有一种玉米的，反正不管是什么服务，他就是在工厂里进行服务的糖化，然后再进行发酵，让这些天然谷物当中的谷氨酸分离出来。接下来在合适的温度和PH值的条件下，和钠结合，最后提纯结晶味精是有国标的，而且是强制国标，要求胃经里谷氨酸钠的含量要大于99%，说白了，味精为什么后面是原料表，不是配料\n因为不需要它就是提取加工出来的单一物质，别的啥也没有了。可以说啊，味精是所有食品添加剂当中配料最简单的。那么其他的纤维添加物呢，比如说味精受挫之后，最大的受益者鸡精呢？鸡精的配料表排名第一是味精，然后是盐，就是加强的谷氨酸钠，再加钠，最后还会再加上核苷酸，也就是再体现而多种蚝油的配料表除了水、糖、盐、蚝汁儿之外，也有谷氨酸钠以及核苷酸。好，我们来给结论，第一，味精有害是谣言，但也并不意味着我们想吃多少就吃多少。谷氨酸是天然氨基酸，但是值得注意的是，后面那个钠，中国很多地方居民饮食习惯口味\n这种食盐的摄入是容易超标的，也就是钠超标。如果你又重盐又重味精或鸡精，那就会加剧钠的超标。第二，其他纤维添加剂当中的这个核苷酸呀，吃多了容易嘌呤超标，尿酸高的朋友尤其",
+    "Timestamp": "2025-03-30T00:10:42.3592763+08:00",
+    "IsRealUser": true,
+    "RecognitionId": "Ky5Jfjsk23S02xQY5Vbqfg",
+    "Priority": 10,
+    "IsProcessed": false,
+    "CompletedText": null,
+    "RecordingPath": "/recordings/recording_20250330_000835.wav",
+    "TextFilePath": "/texts/recording_20250330_000835.txt"
+  }
+]
\ No newline at end of file
diff --git a/ShengShengBuXi/config/newconfig.js b/ShengShengBuXi/config/newconfig.js
new file mode 100644
index 0000000..172857c
--- /dev/null
+++ b/ShengShengBuXi/config/newconfig.js
@@ -0,0 +1 @@
+{"Type":1}
\ No newline at end of file
diff --git a/ShengShengBuXi/config/screen_control.json b/ShengShengBuXi/config/screen_control.json
new file mode 100644
index 0000000..c354f99
--- /dev/null
+++ b/ShengShengBuXi/config/screen_control.json
@@ -0,0 +1 @@
+{"IsManual":false}
\ No newline at end of file
diff --git a/ShengShengBuXi/config/sentences.txt b/ShengShengBuXi/config/sentences.txt
index de66a9a..aa7170c 100644
Binary files a/ShengShengBuXi/config/sentences.txt and b/ShengShengBuXi/config/sentences.txt differ
diff --git a/ShengShengBuXi/config/sentences2.txt b/ShengShengBuXi/config/sentences2.txt
new file mode 100644
index 0000000..4d4bf89
--- /dev/null
+++ b/ShengShengBuXi/config/sentences2.txt
@@ -0,0 +1,27 @@
+记得每到夏天傍晚，您就摇着蒲扇坐在藤椅里，把切好的西瓜最甜那块硬塞给我，自己却啃着靠近皮的白瓤，还笑着说:外公就爱这口，清爽。
+女儿啊 花开了 你否到了吗?
+外公，你在那边过的还好么大家都很想称，记得常回家看看
+外公，今天窗台上的茉莉开了，白盈盈的，就像以前您总别在中山装口袋上的那朵。
+晒被子时闻到阳光味道，突然想起您总说"晒过的被子能藏住太阳"。
+
+路过糕点铺看见桃酥，手已经伸进钱包才想起再没人等我带点心回家了。
+
+梅雨季的墙根又生了青苔，再没人蹲着教我认哪些能入药。
+
+公交卡掉进沙发缝的瞬间，耳边响起您笑我"马虎样像极了你奶奶年轻时"。
+
+超市里荔枝上市了，指尖碰到冰镇外壳就想起您剥好喂我的那碗去核的。
+
+整理旧书时飘出干枯的枫叶书签，您工整的"1973年秋于香山"已经褪色。
+
+台风天窗户砰砰响，再没人半夜摸黑来给我房间加固防风板。
+
+发现第一根白发时，突然懂得您当年让我拔时说的"这是月亮给的银丝"。
+
+中药柜抽屉拉开的气味里，总错觉能听见您碾药时的咳嗽声。
+
+女儿突然说"想太公了"，我才发现她笑起来有您一样的酒窝。
+
+煮糊的粥底粘在锅上，想起您总悄悄刮掉焦层把好的留给我。
+
+老式挂钟敲七下时，还会下意识望向门口等那句"我买豆浆回来了"。
\ No newline at end of file
diff --git a/ShengShengBuXi/success.txt b/ShengShengBuXi/success.txt
new file mode 100644
index 0000000..32b1cdb
Binary files /dev/null and b/ShengShengBuXi/success.txt differ
diff --git a/ShengShengBuXi/temp.txt b/ShengShengBuXi/temp.txt
new file mode 100644
index 0000000..5437e73
--- /dev/null
+++ b/ShengShengBuXi/temp.txt
@@ -0,0 +1,2042 @@
+@page
+@model ShengShengBuXi.Pages.MonitorModel
+@{
+    ViewData["Title"] = "清竹园-中控页面";
+}
+
+<!-- 添加Bootstrap Icons库的引用 -->
+<link rel="stylesheet" href="~/css/bootstrap-icons.css">
+
+<div class="container-fluid">
+    <!-- 头部区域 (100%, 20%) -->
+    <div class="row mb-3">
+        <div class="col-12">
+            <div class="card">
+                <div class="card-body">
+                    <div class="d-flex justify-content-between align-items-center">
+                        <h2 class="my-2">
+                            清竹园-中控页面 <span id="connection-status" class="badge bg-warning">连接中...</span>
+                        </h2>
+
+                        <!-- 通话状态指示器 -->
+                        <div class="d-flex align-items-center">
+                            <div id="status-indicator" class="rounded-circle me-2"
+                                 style="width: 24px; height: 24px; background-color: red;"></div>
+                            <span id="status-text" class="me-3">未检测到通话</span>
+                        </div>
+
+                        <!-- 预设句子类型控制 -->
+                        <div class="btn-group ms-3" role="group">
+                            <span class="me-2 d-flex align-items-center">预设句子类型：</span>
+                            <input type="radio" class="btn-check" name="presetSentenceType" id="presetSentenceType0" value="0" checked onclick="updatePresetSentenceType(0)">
+                            <label class="btn btn-outline-primary" for="presetSentenceType0">默认</label>
+                            <input type="radio" class="btn-check" name="presetSentenceType" id="presetSentenceType1" value="1" onclick="updatePresetSentenceType(1)">
+                            <label class="btn btn-outline-primary" for="presetSentenceType1">预设2</label>
+                        </div>
+
+                        <!-- 控屏开关 - 优化样式 -->
+                        <div class="btn-group ms-3" role="group">
+                            <span class="me-2 d-flex align-items-center">控屏模式：</span>
+                            <input type="radio" class="btn-check" name="screenControl" id="screenControlAuto" value="0"
+                                   checked>
+                            <label class="btn btn-outline-primary" for="screenControlAuto">自动</label>
+                            <input type="radio" class="btn-check" name="screenControl" id="screenControlManual"
+                                   value="1">
+                            <label class="btn btn-outline-primary" for="screenControlManual">手动</label>
+                        </div>
+
+                        <!-- 音频传输开关 - 隐藏 -->
+                        <div class="btn-group ms-3" role="group" style="display: none;">
+                            <input type="radio" class="btn-check" name="audioStreaming" id="audioStreaming1" value="1"
+                                   checked>
+                            <label class="btn btn-outline-success" for="audioStreaming1">开启音频传输</label>
+
+                            <input type="radio" class="btn-check" name="audioStreaming" id="audioStreaming0" value="0"
+                                   style="display: none;">
+                            <label class="btn btn-outline-danger" for="audioStreaming0"
+                                   style="display: none;">关闭音频传输</label>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 主体区域 (20%+60%+20%, 80%) -->
+        <div class="row">
+            <!-- 左侧文字列表 (20%, 80%) -->
+            <div class="col-3">
+                <div class="card h-100">
+                    <div class="card-header">
+                        <h5 class="mb-0">语音列表</h5>
+                    </div>
+                    <div class="card-body p-0">
+                        <div id="monitor-text-list" class="list-group list-group-flush"
+                             style="max-height: 75vh; overflow-y: auto;">
+                            <!-- 文本列表内容将通过JS动态填充 -->
+                            <div class="text-center text-muted p-3">加载中...</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 中间区域 (60%, 80%) -->
+            <div class="col-6">
+                <div class="card h-100">
+                    <div class="card-header d-flex justify-content-between align-items-center">
+                        <div>
+                            <button class="btn btn-sm btn-outline-primary me-2" onclick="copyDisplayedText()">
+                                <i class="bi bi-clipboard"></i> 复制文本
+                            </button>
+                        </div>
+                        <button class="btn btn-sm btn-outline-secondary" onclick="closeTextDisplay()">关闭</button>
+                    </div>
+                    <div class="card-body">
+                        <div id="content-area" style="height: 75vh;">
+                            <!-- 文本显示区域 -->
+                            <div id="text-display-area" class="mb-4" style="display: none; height: 20%;">
+                                <div class="card">
+                                    <div class="card-body">
+                                        <p id="displayed-text" class="mb-0"></p>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- 文本输入区域 -->
+                            <div id="input-text-area" style="height: 40%;">
+                                <div class="card h-100">
+                                    <div class="card-header">
+                                        <h5 class="mb-0">
+                                            文本编辑
+                                        </h5>
+                                    </div>
+                                    <div class="card-body">
+                                        <textarea id="text-input" class="form-control h-100" placeholder="请输入要显示的文本..."></textarea>
+
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- 按钮组区域 - 隐藏添加并移除按钮 -->
+                            <div id="action-buttons-area" class="mt-3" style="height: 20%;">
+                                <div class="card h-100">
+                                    <div class="card-body d-flex justify-content-center align-items-center">
+                                        <button id="add-text-btn" class="btn btn-primary me-3" data-bs-toggle="tooltip"
+                                                title="将文本添加到显示队列，并显示在大屏上" onclick="addDisplayText()">
+                                            <i class="bi bi-plus-circle"></i> 显示到大屏
+                                        </button>
+                                        <button id="add-and-remove-btn" class="btn btn-warning" data-bs-toggle="tooltip"
+                                                title="将文本添加到显示队列，并从监控列表中移除当前选中项" onclick="addDisplayTextAndRemoveMonitor()"
+                                                style="display: none;">
+                                            <i class="bi bi-arrow-right-circle"></i> 添加并移除
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- 其他中间内容 -->
+                            <div id="other-content">
+                                <!-- 中间的空div -->
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 右侧文字列表 (20%, 80%) -->
+            <div class="col-3">
+                <div class="card h-100">
+                    <div class="card-header">
+                        <h5 class="mb-0">显示文本列表</h5>
+                    </div>
+                    <div class="card-body p-0">
+                        <div id="display-text-list" class="list-group list-group-flush"
+                             style="max-height: 75vh; overflow-y: auto;">
+                            <!-- 文本列表内容将通过JS动态填充 -->
+                            <div class="text-center text-muted p-3">加载中...</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 预设句子控制区域 -->
+        <div class="row mt-3">
+            <div class="col-12">
+                <div class="card">
+                    <div class="card-header">
+                        <h5 class="mb-0">预设句子控制</h5>
+                    </div>
+                    <div class="card-body">
+                        <div class="row">
+                            <div class="col-md-12">
+                                <div class="form-group">
+                                    <label class="form-label">添加预设句子</label>
+                                    <div class="input-group">
+                                        <input type="text" class="form-control" id="presetSentenceInput" placeholder="输入预设句子...">
+                                        <button class="btn btn-primary" onclick="addPresetSentence()">添加</button>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 调试区域 (底部) -->
+        <div class="row mt-3">
+            <div class="col-12">
+                <div class="card">
+                    <div class="card-header d-flex justify-content-between align-items-center">
+                        <span>调试信息</span>
+                        <div>
+                            <button class="btn btn-sm btn-outline-danger me-2" onclick="clearDebug()">清空</button>
+                            <button class="btn btn-sm btn-outline-secondary" onclick="toggleDebug()">隐藏</button>
+                        </div>
+                    </div>
+                    <div class="card-body">
+                        <pre id="debug-log" style="max-height: 150px; overflow-y: auto;"></pre>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 消息区域 -->
+    <div id="message-area" class="position-fixed bottom-0 end-0 p-3" style="z-index: 1050;"></div>
+
+    <!-- 来电确认对话框 -->
+    <div class="modal fade" id="callConfirmDialog" tabindex="-1" aria-labelledby="callConfirmDialogLabel"
+         aria-hidden="true" data-bs-backdrop="static" data-bs-keyboard="false">
+        <div class="modal-dialog modal-dialog-centered">
+            <div class="modal-content">
+                <div class="modal-header bg-primary text-white">
+                    <h5 class="modal-title" id="callConfirmDialogLabel">
+                        <i class="bi bi-telephone-inbound"></i> 来电提醒
+                    </h5>
+                </div>
+                <div class="modal-body text-center py-4">
+                    <div class="mb-3">
+                        <i class="bi bi-telephone-fill text-primary" style="font-size: 3rem;"></i>
+                    </div>
+                    <h5>检测到新的通话</h5>
+                    <p class="text-muted">请点击接听开始播放音频</p>
+                </div>
+                <div class="modal-footer justify-content-center">
+                    <button type="button" class="btn btn-primary" onclick="confirmCall()">
+                        <i class="bi bi-telephone"></i> 接听
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    @section Scripts {
+        <script src="~/lib/microsoft-signalr/signalr.min.js"></script>
+
+        <script src="https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js"></script>
+        <script src='https://web.sdk.qcloud.com/trtc/webrtc/v5/dist/trtc.js'></script>
+        <script src="~/js/lib-generate-test-usersig.min.js"></script>
+        <script src="~/js/generateTestUserSig.js"></script>
+        <script>
+            let connection = null;
+            let refreshDisplayInterval = null;
+            let callInProgress = false;
+            let isActiveShow = false;
+            // 当前播放的音频元素和按钮引用
+            let currentAudio = null;
+            let currentPlayButton = null;
+
+            // 控屏开关状态
+            let isManualScreenControl = false;
+
+            // 实时音频相关变量
+            let audioContext = null;
+            let audioStreamSource = null;
+            let isAudioStreamEnabled = false;
+            let audioGainNode = null;
+            let currentVolume = 1.0; // 默认音量
+            let volumeBoost = 3.0; // 音量增益倍数，提高接收到的音频音量
+
+            const sdkAppId = 1600079538;
+            const sdkSecretKey = "df2427757c0ec29ae8ca45611ddb70381144d55338e5ac73c2da27a9c32729f6";
+            let userId = "监听者：" + Math.random().toString(36).substring(2, 10);
+            let roomId = 8888;
+
+            let trtc = TRTC.create();
+
+            async function enterRoom() {
+                try {
+                    trtc = TRTC.create();
+                    // 生成用户签名
+                    const { userSig } = genTestUserSig({ sdkAppId, userId, sdkSecretKey });
+                    // 进入房间
+                    await trtc.enterRoom({ sdkAppId, userId, userSig, roomId: roomId });
+                } catch (error) {
+
+                }
+            }
+
+
+            async function leaveRoom() {
+                try {
+                    await trtc.exitRoom();
+                    trtc.destroy();
+                    // 更新状态指示器为红色（已断开）
+                } catch (error) {
+
+                }
+            }
+
+            // 调试日志
+            function log(message) {
+                const timestamp = new Date().toLocaleTimeString();
+                const logMsg = `[${timestamp}] ${message}`;
+                console.log(logMsg);
+                const logElem = document.getElementById("debug-log");
+                if (logElem) {
+                    const logLine = document.createElement("div");
+                    logLine.textContent = logMsg;
+                    logElem.insertBefore(logLine, logElem.firstChild);
+                }
+            }
+
+            // 显示/隐藏调试区域
+            function toggleDebug() {
+                const debugCard = document.querySelector("#debug-log").closest(".card");
+                const isVisible = debugCard.style.display !== "none";
+                debugCard.style.display = isVisible ? "none" : "";
+            }
+
+            // 清空调试日志
+            function clearDebug() {
+                document.getElementById("debug-log").innerHTML = "";
+            }
+
+            // 显示消息提示
+            function showMessage(message, type = 'info', duration = 5000) {
+                const messageArea = document.getElementById("message-area");
+                const alert = document.createElement("div");
+                alert.className = `alert alert-${type} alert-dismissible fade show`;
+                alert.innerHTML = `
+                                                                ${message}
+                                                                <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+                                                            `;
+                messageArea.appendChild(alert);
+
+                // 自动移除
+                setTimeout(() => {
+                    alert.classList.remove('show');
+                    setTimeout(() => alert.remove(), 150);
+                }, duration);
+            }
+
+            // 更新连接状态
+            function updateConnectionStatus(status, type = 'warning') {
+                const statusElem = document.getElementById("connection-status");
+                statusElem.className = `badge bg-${type}`;
+                statusElem.textContent = status;
+            }
+
+            // 初始化SignalR连接
+            function initSignalR() {
+                log("初始化SignalR连接...");
+                updateConnectionStatus("连接中...", "warning");
+
+                // 创建连接
+                connection = new signalR.HubConnectionBuilder()
+                    .withUrl("/audiohub")
+                    .configureLogging(signalR.LogLevel.Debug)
+                    .withAutomaticReconnect()
+                    .build();
+
+                // 注册连接事件处理程序
+                connection.onreconnecting(error => {
+                    log("重新连接中: " + (error ? error.message : "未知错误"));
+                    updateConnectionStatus("重连中...", "warning");
+                });
+
+                connection.onreconnected(connectionId => {
+                    log("已重新连接，ID: " + connectionId);
+                    updateConnectionStatus("已连接", "success");
+                    // 重新注册
+                    registerAsMonitor();
+                });
+
+                connection.onclose(error => {
+                    log("连接已关闭: " + (error ? error.message : ""));
+                    updateConnectionStatus("已断开", "danger");
+                    // 5秒后重连
+                    setTimeout(() => startConnection(), 5000);
+                });
+
+                // 注册服务器消息处理程序
+                setupSignalRHandlers();
+
+                // 建立连接
+                startConnection();
+            }
+
+            // 开始连接
+            function startConnection() {
+                log("正在连接到服务器...");
+
+                connection.start()
+                    .then(() => {
+                        log("已连接到服务器，连接ID: " + connection.connectionId);
+                        updateConnectionStatus("已连接", "success");
+                        registerAsMonitor();
+                    })
+                    .catch(err => {
+                        log("连接失败: " + err);
+                        updateConnectionStatus("连接失败", "danger");
+                        setTimeout(() => startConnection(), 5000);
+                    });
+            }
+
+            // 注册为中控客户端
+            function registerAsMonitor() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法注册：未连接");
+                    return;
+                }
+
+                log("正在注册为中控客户端...");
+
+                connection.invoke("RegisterClient", 2, "中控监视页面")
+                    .then(() => {
+                        log("已注册为中控客户端");
+                        // 加载初始数据
+                        loadMonitorTextList();
+                        loadDisplayTextList();
+
+                        // 获取当前显示模式
+                        getServerDisplayType();
+
+                        // 获取当前音频流设置
+                        getServerAudioStreamingSetting();
+
+                        // 获取当前控屏设置
+                        getServerScreenControlSetting();
+
+                         // 获取当前预设句子类型设置
+                    getServerPresetSentenceTypeSetting();
+
+                        // 设置定时刷新显示列表
+                        if (refreshDisplayInterval) {
+                            clearInterval(refreshDisplayInterval);
+                        }
+                        refreshDisplayInterval = setInterval(loadDisplayTextList, 10000);  // 每10秒刷新一次
+                    })
+                    .catch(err => {
+                        log("注册失败: " + err);
+                        showMessage("注册失败: " + err, "danger");
+                    });
+            }
+
+            // 设置SignalR事件处理程序
+            function setupSignalRHandlers() {
+                // 注册确认
+                connection.on("RegistrationConfirmed", (clientId) => {
+                    log("注册确认，客户端ID: " + clientId);
+                    showMessage("已注册为中控客户端", "success");
+                });
+
+                // 注册失败
+                connection.on("RegistrationFailed", (reason) => {
+                    log("注册失败: " + reason);
+                    showMessage("注册失败: " + reason, "danger");
+                });
+
+                // 通话状态改变
+                connection.on("CallStateChanged", (isActive) => {
+                    updateCallStatus(isActive);
+                });
+
+                // 错误消息
+                connection.on("Error", (message) => {
+                    log("错误: " + message);
+                    showMessage("错误: " + message, "danger");
+                });
+
+                // 接收实时语音识别结果
+                connection.on("ReceiveSpeechToTextResult", (result) => {
+                    log(`接收到实时语音识别结果: ${result.substring(0, 30)}${result.length > 30 ? '...' : ''}`);
+
+                    // 使用防抖动技术显示实时识别结果，避免频繁更新导致页面卡顿
+                    if (window.realtimeTextDebounceTimer) {
+                        clearTimeout(window.realtimeTextDebounceTimer);
+                    }
+                    window.realtimeTextDebounceTimer = setTimeout(() => {
+                        showRealtimeTextResult(result);
+                    }, 300); // 300毫秒的防抖动延迟
+                });
+
+                // 接收最终语音识别结果
+                connection.on("ReceiveSpeechToEndTextResult", (result) => {
+                    log(`接收到最终语音识别结果: ${result.substring(0, 30)}${result.length > 30 ? '...' : ''}`);
+
+                    // 清除任何正在进行的实时文本更新定时器
+                    if (window.realtimeTextDebounceTimer) {
+                        clearTimeout(window.realtimeTextDebounceTimer);
+                    }
+
+                    // 显示最终识别结果
+                    showFinalTextResult(result);
+
+                    // 同时添加到监控列表的顶部（如果不存在于列表中）
+                    addToMonitorList(result);
+                });
+
+                // 显示模式更新消息
+                connection.on("DisplayTypeChanged", (displayType) => {
+                    log(`服务器显示模式已更改为: ${displayType}`);
+                    updateDisplayModeUI(displayType);
+                });
+
+                // 显示模式更新结果
+                connection.on("DisplayTypeUpdated", (success, message) => {
+                    if (success) {
+                        log(`显示模式更新成功: ${message}`);
+                        showMessage(message, "success");
+                    } else {
+                        log(`显示模式更新失败: ${message}`);
+                        showMessage(message, "danger");
+                    }
+                });
+
+                // 接收实时音频数据
+                connection.on("ReceiveAudioData", (audioData) => {
+                    if (!isActiveShow) {
+                        // 添加音频流持续检测逻辑
+                        if (!window.audioStreamStartTime) {
+                            // 设置音频流开始接收时间
+                            window.audioStreamStartTime = Date.now();
+                            log("检测到音频流，开始计时");
+                        } else {
+                            // 检查是否超过5秒
+                            const elapsedTime = Date.now() - window.audioStreamStartTime;
+                            if (elapsedTime > 5000) {
+                                log(`音频流持续时间 ${(elapsedTime/1000).toFixed(1)}秒，触发通话状态更新`);
+                                window.audioStreamStartTime = null; // 重置计时器
+                                updateCallStatus(true);
+                            }
+                        }
+                        return;
+                    } else {
+                        // 重置音频流计时器
+                        window.audioStreamStartTime = null;
+                    }
+                });
+
+                // 音频流设置更新消息
+                connection.on("AudioStreamingChanged", (enabled) => {
+                    log(`服务器音频流设置已更改为: ${enabled ? "开启" : "关闭"}`);
+                    updateAudioStreamingUI(enabled);
+                });
+
+                // 音频流设置更新结果
+                connection.on("AudioStreamingUpdated", (success, message) => {
+                    if (success) {
+                        log(`音频流设置更新成功: ${message}`);
+                        showMessage(message, "success");
+                    } else {
+                        log(`音频流设置更新失败: ${message}`);
+                        showMessage(message, "danger");
+                    }
+                });
+
+                // 控屏设置更新消息
+                connection.on("ScreenControlSettingChanged", (isManual) => {
+                    log(`服务器控屏设置已更改为: ${isManual ? "手动" : "自动"}`);
+                    updateScreenControlUI(isManual);
+                });
+
+                // 控屏设置更新结果
+                connection.on("ScreenControlSettingUpdated", (success, message) => {
+                    if (success) {
+                        log(`控屏设置更新成功: ${message}`);
+                        showMessage(message, "success");
+                    } else {
+                        log(`控屏设置更新失败: ${message}`);
+                        showMessage(message, "danger");
+                    }
+                });
+            }
+
+            // 更新通话状态
+            function updateCallStatus(isActive) {
+                isActiveShow = isActive;
+                if (isActive) {
+                    // 当检测到新通话时，先显示确认对话框
+                    const confirmDialog = new bootstrap.Modal(document.getElementById('callConfirmDialog'));
+                    confirmDialog.show();
+                    enterRoom();
+                    return; // 等待用户确认后再继续处理
+                } else {
+                    const indicator = document.getElementById("status-indicator");
+                    const statusText = document.getElementById("status-text");
+                    indicator.style.backgroundColor = "red";
+                    statusText.textContent = "未检测到通话";
+
+                    // 如果确认对话框还在显示（用户未点击接听），则自动关闭
+                    const confirmDialog = bootstrap.Modal.getInstance(document.getElementById('callConfirmDialog'));
+                    if (confirmDialog) {
+                        confirmDialog.hide();
+                        exitRoom();
+                        log("通话已结束，自动关闭确认对话框");
+                    }
+                }
+
+                // 有新通话时刷新监控列表
+                loadMonitorTextList();
+            }
+
+            // 用户确认接听通话
+            function confirmCall() {
+                const indicator = document.getElementById("status-indicator");
+                const statusText = document.getElementById("status-text");
+                indicator.style.backgroundColor = "green";
+                statusText.textContent = "正在通话中";
+                callInProgress = true;
+
+                // 初始化音频上下文（如果需要且启用了音频流）
+                if (isAudioStreamEnabled) {
+                    // 如果存在音频上下文，则先尝试关闭，然后重新创建
+                    if (audioContext) {
+                        log("重置音频上下文以确保新的通话正常播放");
+                        try {
+                            // 释放旧的增益节点
+                            if (audioGainNode) {
+                                audioGainNode.disconnect();
+                                audioGainNode = null;
+                            }
+                            // 关闭旧的音频上下文
+                            audioContext.close().catch(e => log("关闭音频上下文失败: " + e));
+                            audioContext = null;
+                        } catch (e) {
+                            log("重置音频上下文失败: " + e);
+                        }
+                    }
+
+                    // 创建新的音频上下文
+                    initAudioContext();
+                }
+
+                // 关闭确认对话框
+                const confirmDialog = bootstrap.Modal.getInstance(document.getElementById('callConfirmDialog'));
+                if (confirmDialog) {
+                    confirmDialog.hide();
+                }
+
+                // 刷新监控列表
+                loadMonitorTextList();
+            }
+
+            // 加载监控文本列表
+            function loadMonitorTextList() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法加载监控文本列表：未连接");
+                    return;
+                }
+
+                log("加载监控文本列表...");
+
+                connection.invoke("GetMonitorTextList")
+                    .then(data => {
+                        log(`获取到${data.length}条监控文本`);
+                        renderMonitorTextList(data);
+                    })
+                    .catch(err => {
+                        log("获取监控文本列表失败: " + err);
+                        showMessage("获取监控文本列表失败", "danger");
+                    });
+            }
+
+            // 渲染监控文本列表
+            function renderMonitorTextList(data) {
+                const container = document.getElementById("monitor-text-list");
+                container.innerHTML = ""; // 清空现有内容
+
+                if (!data || data.length === 0) {
+                    container.innerHTML = '<div class="text-center text-muted p-3">暂无监控文本</div>';
+                    return;
+                }
+
+                // 按时间倒序排列
+                data.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+                // 渲染每一项
+                data.forEach(item => {
+                    const listItem = document.createElement("div");
+                    listItem.className = "list-group-item";
+                    listItem.dataset.id = item.id;
+                    // 存储原始文本，用于点击后显示
+                    listItem.dataset.fullText = item.text || item.completedText || "无文本内容";
+
+                    // 添加点击事件
+                    listItem.addEventListener('click', function (e) {
+                        // 如果点击的是按钮，不触发选择
+                        if (e.target.tagName === 'BUTTON' || e.target.tagName === 'I' ||
+                            e.target.closest('button')) {
+                            return;
+                        }
+
+                        // 移除其他项的active类
+                        document.querySelectorAll("#monitor-text-list .list-group-item").forEach(item => {
+                            item.classList.remove("active");
+                        });
+
+                        // 添加active类到当前项
+                        this.classList.add("active");
+
+                        // 显示文本
+                        displayTextInCenter(this.dataset.fullText);
+                    });
+
+                    // 转换日期格式
+                    const date = new Date(item.timestamp);
+                    const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
+
+                    const text = item.text || item.completedText || "无文本内容";
+                    // 截取前10个字符，若不足10个则全部显示
+                    const shortText = text.length > 10 ? text.substring(0, 10) : text;
+
+                    listItem.innerHTML = `
+                                                                            <div class="d-flex justify-content-between align-items-start mb-1">
+                                                                                <small class="text-muted">【${shortText}】</small>
+                                                                                <div class="btn-group btn-group-sm">
+                                                                                    <button class="btn btn-outline-primary btn-sm" onclick="playAudio('${item.recordingPath || ''}', this)">
+                                                                                        <i class="bi bi-play-fill"></i>
+                                                                                    </button>
+                                                                                    <button class="btn btn-outline-secondary btn-sm" onclick="downloadRecording('${item.recordingPath || ''}')">
+                                                                                        <i class="bi bi-download"></i>
+                                                                                    </button>
+                                                                                    <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${item.id}')">
+                                                                                        <i class="bi bi-trash"></i>
+                                                                                    </button>
+                                                                                </div>
+                                                                            </div>
+                                                                            <div>${formattedDate}</div>
+                                                                        `;
+
+                    container.appendChild(listItem);
+                });
+            }
+
+            // 删除监控文本
+            function deleteMonitorText(id) {
+                if (!id || !connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法删除监控文本：未连接或ID无效");
+                    return;
+                }
+
+                log(`正在删除监控文本: ${id}`);
+
+                connection.invoke("DelMonitorText", id)
+                    .then(result => {
+                        log(`删除监控文本${result ? '成功' : '失败'}`);
+                        if (result) {
+                            // 从UI中移除该项
+                            const item = document.querySelector(`#monitor-text-list .list-group-item[data-id="${id}"]`);
+                            if (item) {
+                                item.remove();
+                            }
+                            showMessage("已删除文本", "success");
+                        } else {
+                            showMessage("删除文本失败", "warning");
+                        }
+                    })
+                    .catch(err => {
+                        log("删除监控文本失败: " + err);
+                        showMessage("删除监控文本失败: " + err, "danger");
+                    });
+            }
+
+            // 播放或暂停音频
+            function playAudio(path, buttonElement) {
+                // 获取按钮元素
+                const button = buttonElement || event.currentTarget;
+                const buttonIcon = button.querySelector('i');
+
+                // 如果没有路径
+                if (!path) {
+                    showMessage("无可播放的录音", "warning");
+                    return;
+                }
+
+                // 如果是当前正在播放的音频
+                if (currentAudio && currentPlayButton === button) {
+                    if (currentAudio.paused) {
+                        // 如果当前是暂停状态，则继续播放
+                        log(`继续播放音频: ${path}`);
+                        currentAudio.play()
+                            .then(() => {
+                                // 更改按钮图标为暂停
+                                buttonIcon.className = "bi bi-pause-fill";
+                                showMessage("继续播放音频", "info");
+                            })
+                            .catch(err => {
+                                showMessage(`播放失败: ${err}`, "danger");
+                                log(`继续播放失败: ${err}`);
+                            });
+                    } else {
+                        // 如果当前是播放状态，则暂停
+                        log(`暂停播放音频: ${path}`);
+                        currentAudio.pause();
+                        // 更改按钮图标为播放
+                        buttonIcon.className = "bi bi-play-fill";
+                        showMessage("已暂停播放", "info");
+                    }
+                    return;
+                }
+
+                // 如果有其他正在播放的音频，先停止它
+                if (currentAudio) {
+                    currentAudio.pause();
+                    // 恢复之前的播放按钮图标
+                    if (currentPlayButton && currentPlayButton.querySelector('i')) {
+                        currentPlayButton.querySelector('i').className = "bi bi-play-fill";
+                    }
+                }
+
+                log(`播放音频: ${path}`);
+
+                // 创建新的音频元素
+                const audioElement = new Audio(path);
+
+                // 应用当前音量设置
+                audioElement.volume = currentVolume;
+
+                // 设置当前播放的音频和按钮
+                currentAudio = audioElement;
+                currentPlayButton = button;
+
+                // 添加事件处理
+                audioElement.addEventListener('error', () => {
+                    showMessage("无法播放音频文件，可能不存在或格式不支持", "warning");
+                    log(`音频播放失败: ${path}`);
+                    // 重置当前播放状态
+                    currentAudio = null;
+                    currentPlayButton = null;
+                    buttonIcon.className = "bi bi-play-fill";
+                });
+
+                audioElement.addEventListener('loadeddata', () => {
+                    log(`音频已加载，开始播放: ${path}, 音量: ${currentVolume * 100}%`);
+                });
+
+                audioElement.addEventListener('ended', () => {
+                    log(`音频播放结束: ${path}`);
+                    // 重置按钮状态
+                    buttonIcon.className = "bi bi-play-fill";
+                    // 重置当前播放状态
+                    currentAudio = null;
+                    currentPlayButton = null;
+                });
+
+                // 播放音频
+                audioElement.play()
+                    .then(() => {
+                        // 更改按钮图标为暂停
+                        buttonIcon.className = "bi bi-pause-fill";
+                        showMessage("正在播放音频", "info");
+                    })
+                    .catch(err => {
+                        showMessage(`播放失败: ${err}`, "danger");
+                        log(`播放失败: ${err}`);
+                        // 重置当前播放状态
+                        currentAudio = null;
+                        currentPlayButton = null;
+                    });
+            }
+
+            // 下载录音
+            function downloadRecording(path) {
+                if (!path) {
+                    showMessage("无可下载的录音", "warning");
+                    return;
+                }
+
+                log(`下载录音: ${path}`);
+
+                // 创建一个链接元素用于下载
+                const a = document.createElement('a');
+                a.href = path;
+                a.download = path.split('/').pop(); // 从路径中提取文件名
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+
+                showMessage("正在下载录音文件", "info");
+            }
+
+            // 加载显示文本列表
+            function loadDisplayTextList() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法加载显示文本列表：未连接");
+                    return;
+                }
+
+                log("加载显示文本列表...");
+
+                connection.invoke("GetDisplayList")
+                    .then(data => {
+                        log(`获取到${data.length}条显示文本`);
+                        renderDisplayTextList(data);
+                    })
+                    .catch(err => {
+                        log("获取显示文本列表失败: " + err);
+                    });
+            }
+
+            // 渲染显示文本列表
+            function renderDisplayTextList(data) {
+                const container = document.getElementById("display-text-list");
+                container.innerHTML = ""; // 清空现有内容
+
+                if (!data || data.length === 0) {
+                    container.innerHTML = '<div class="text-center text-muted p-3">暂无显示文本</div>';
+                    return;
+                }
+
+                // 按时间倒序排列
+                data.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+                // 渲染每一项
+                data.forEach(item => {
+                    const listItem = document.createElement("div");
+                    listItem.className = "list-group-item";
+                    // 存储原始文本，用于点击后显示
+                    listItem.dataset.fullText = item.text || item.completedText || "无文本内容";
+
+                    // 添加点击事件
+                    listItem.addEventListener('click', function () {
+                        onlyDisplayTextInCenter(this.dataset.fullText);
+                    });
+
+                    // 转换日期格式
+                    const date = new Date(item.timestamp);
+                    const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
+
+                    const text = item.text || item.completedText || "无文本内容";
+                    // 截取前5个字符，若不足5个则全部显示
+                    const shortText = text.length > 5 ? text.substring(0, 5) : text;
+
+                    listItem.innerHTML = `
+                                                                            <div class="mb-1">
+                                                                                <small class="text-muted">${formattedDate}</small>
+                                                                            </div>
+                                                                            <div>【${shortText}】</div>
+                                                                        `;
+
+                    container.appendChild(listItem);
+                });
+            }
+
+            // 监听显示模式单选按钮的变化
+            function setupDisplayModeListeners() {
+                const displayModeButtons = document.querySelectorAll('input[name="displayMode"]');
+                displayModeButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const mode = parseInt(this.value);
+                        log(`显示模式已切换为: ${mode === 0 ? "识别立即显示" : "手动显示"}`);
+
+                        // 调用服务器端方法更新显示模式
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateDisplayType", mode)
+                                .then(() => {
+                                    showMessage(`已切换为${mode === 0 ? "识别立即显示" : "手动显示"}模式`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新显示模式失败: ${err}`);
+                                    showMessage("切换显示模式失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentMode = mode === 0 ? 1 : 0;
+                                    document.getElementById(`displayMode${currentMode}`).checked = true;
+                                });
+                        } else {
+                            log("无法更新显示模式：未连接到服务器");
+                            showMessage("无法更新显示模式：未连接到服务器", "warning");
+                        }
+                    });
+                });
+
+                // 监听音频传输单选按钮的变化
+                const audioStreamingButtons = document.querySelectorAll('input[name="audioStreaming"]');
+                audioStreamingButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const enabled = parseInt(this.value) === 1;
+                        log(`音频传输已切换为: ${enabled ? "开启" : "关闭"}`);
+
+                        // 设置本地音频流状态
+                        isAudioStreamEnabled = enabled;
+
+                        // 如果开启了音频流，初始化音频上下文
+                        if (enabled && callInProgress) {
+                            initAudioContext();
+                        }
+
+                        // 调用服务器端方法更新音频流设置
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateAudioStreaming", enabled)
+                                .then(() => {
+                                    showMessage(`已${enabled ? "开启" : "关闭"}音频传输`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新音频流设置失败: ${err}`);
+                                    showMessage("切换音频传输失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentValue = enabled ? 0 : 1;
+                                    document.getElementById(`audioStreaming${currentValue}`).checked = true;
+                                    isAudioStreamEnabled = !enabled;
+                                });
+                        } else {
+                            log("无法更新音频流设置：未连接到服务器");
+                            showMessage("无法更新音频流设置：未连接到服务器", "warning");
+                        }
+                    });
+                });
+            }
+
+            // 设置音频流开关监听器
+            function setupAudioStreamingListeners() {
+                const audioStreamingButtons = document.querySelectorAll('input[name="audioStreaming"]');
+                audioStreamingButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const enabled = parseInt(this.value) === 1;
+                        isAudioStreamEnabled = enabled;
+                        log(`音频流已切换为: ${enabled ? "开启" : "关闭"}`);
+
+                        // 如果开启了音频流，初始化音频上下文
+                        if (enabled && callInProgress) {
+                            initAudioContext();
+                        }
+
+                        // 调用服务器端方法更新音频流设置
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateAudioStreaming", enabled)
+                                .then(() => {
+                                    showMessage(`已${enabled ? "开启" : "关闭"}音频传输`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新音频流设置失败: ${err}`);
+                                    showMessage("切换音频传输失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentValue = enabled ? 0 : 1;
+                                    document.getElementById(`audioStreaming${currentValue}`).checked = true;
+                                    isAudioStreamEnabled = !enabled;
+                                });
+                        } else {
+                            log("无法更新音频流设置：未连接到服务器");
+                            showMessage("无法更新音频流设置：未连接到服务器", "warning");
+                        }
+                    });
+                });
+            }
+
+            // 设置控屏开关监听器
+            function setupScreenControlListeners() {
+                console.log('aaaa')
+                const screenControlButtons = document.querySelectorAll('input[name="screenControl"]');
+                screenControlButtons.forEach(radio => {
+                    radio.addEventListener('change', function () {
+                        const isManual = parseInt(this.value) === 1;
+                        isManualScreenControl = isManual;
+                        log(`控屏模式已切换为: ${isManual ? "手动" : "自动"}`);
+
+                        // 调用服务器端方法更新控屏设置
+                        if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                            connection.invoke("UpdateScreenControlSetting", isManual)
+                                .then(() => {
+                                    showMessage(`已切换为${isManual ? "手动" : "自动"}控屏模式`, "success");
+                                })
+                                .catch(err => {
+                                    log(`更新控屏设置失败: ${err}`);
+                                    showMessage("切换控屏模式失败", "danger");
+
+                                    // 恢复原来的选择
+                                    const currentValue = isManual ? 0 : 1;
+                                    document.getElementById(`screenControl${currentValue === 0 ? 'Auto' : 'Manual'}`).checked = true;
+                                });
+                        }
+                    });
+                });
+            }
+
+            // 设置音量控制监听器
+            function setupVolumeControlListener() {
+                const volumeControl = document.getElementById('volumeControl');
+                if (volumeControl) {
+                    volumeControl.addEventListener('input', function (e) {
+                        currentVolume = parseFloat(e.target.value);
+                        log(`音量已调整为: ${currentVolume * 100}%`);
+
+                        // 如果已经创建了增益节点，立即应用音量设置
+                        if (audioGainNode) {
+                            audioGainNode.gain.value = currentVolume;
+                        }
+
+                        // 同时调整已播放的录音音量
+                        if (currentAudio) {
+                            currentAudio.volume = currentVolume;
+                        }
+                    });
+                }
+            }
+
+            // 初始化页面
+            document.addEventListener('DOMContentLoaded', function () {
+
+                // 初始化音频上下文
+                initAudioContext();
+
+                // 初始化SignalR连接
+                initSignalR();
+
+                // 设置各种事件监听器
+                // setupEventListeners();
+                setupDisplayModeListeners();
+                setupAudioStreamingListeners();
+                setupScreenControlListeners();
+
+                // 初始化音量控制
+                setupVolumeControl();
+
+                // 注册为监控端
+                registerAsMonitor();
+
+                // 初始化工具提示
+                setTimeout(initTooltips, 1000);
+
+                // 默认开启音频传输
+                document.getElementById("audioStreaming1").checked = true;
+                isAudioStreamEnabled = true;
+
+                // 初始化UI和事件
+                initUI();
+
+
+            });
+
+            // 页面卸载前清理资源
+            window.addEventListener('beforeunload', function () {
+                if (refreshDisplayInterval) {
+                    clearInterval(refreshDisplayInterval);
+                }
+
+                // 关闭音频上下文
+                if (audioContext) {
+                    audioContext.close().catch(e => console.log("关闭音频上下文失败: " + e));
+                    audioContext = null;
+                }
+            });
+
+            // 更新显示模式UI
+            function updateDisplayModeUI(displayType) {
+                // 将displayType转换为整数确保类型匹配
+                displayType = parseInt(displayType);
+
+                // 确保值在有效范围内(0或1)
+                if (displayType === 0 || displayType === 1) {
+                    // 更新单选按钮状态
+                    document.getElementById(`displayMode${displayType}`).checked = true;
+
+                    log(`UI显示模式已更新为: ${displayType === 0 ? "识别立即显示" : "手动显示"}`);
+                }
+            }
+
+            // 获取服务器当前的显示模式
+            function getServerDisplayType() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取显示模式：未连接");
+                    return;
+                }
+
+                log("获取服务器当前显示模式...");
+
+                connection.invoke("GetDisplayType")
+                    .then(displayType => {
+                        log(`获取到服务器当前显示模式: ${displayType}`);
+                        updateDisplayModeUI(displayType);
+                    })
+                    .catch(err => {
+                        log("获取显示模式失败: " + err);
+                    });
+            }
+
+            // 在中间区域显示文本（用于左侧列表，包含编辑功能）
+            function displayTextInCenter(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.textContent = text;
+
+                // 同时将文本填入输入框
+               // document.getElementById("text-input").value = text;
+
+                // 显示文本编辑区域和按钮区域
+                document.getElementById("input-text-area").style.display = "block";
+                document.getElementById("action-buttons-area").style.display = "block";
+
+                log("在中间区域显示文本（带编辑功能）");
+            }
+
+            // 在中间区域只显示文本（用于右侧列表，不包含编辑功能）
+            function onlyDisplayTextInCenter(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.textContent = text;
+
+                // 隐藏文本编辑区域和按钮区域
+                document.getElementById("input-text-area").style.display = "none";
+                document.getElementById("action-buttons-area").style.display = "none";
+
+                log("在中间区域只显示文本（无编辑功能）");
+            }
+
+            // 关闭文本显示
+            function closeTextDisplay() {
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "none";
+
+                // 重新显示编辑区域和按钮区域
+                document.getElementById("input-text-area").style.display = "block";
+                document.getElementById("action-buttons-area").style.display = "block";
+
+                log("关闭文本显示");
+            }
+
+            // 复制显示的文本
+            function copyDisplayedText() {
+                const textArea = document.getElementById("displayed-text");
+                const text = textArea.textContent;
+
+                if (!text || text.trim() === "") {
+                    showMessage("请先从左侧列表选择一条文本记录", "warning");
+                    log("尝试复制文本失败：未选择文本");
+                    return;
+                }
+
+                // 创建临时textarea元素用于复制
+                const tempTextArea = document.createElement("textarea");
+                tempTextArea.value = text;
+                document.body.appendChild(tempTextArea);
+                tempTextArea.select();
+
+                try {
+                    // 尝试复制到剪贴板
+                    const success = document.execCommand("copy");
+                    if (success) {
+                        showMessage("文本已复制到剪贴板", "success");
+                        log("文本已复制到剪贴板");
+                    } else {
+                        showMessage("复制失败，请手动复制", "warning");
+                        log("复制文本失败：execCommand返回false");
+                    }
+                } catch (err) {
+                    showMessage("复制失败: " + err, "danger");
+                    log("复制文本失败: " + err);
+                }
+
+                // 移除临时元素
+                document.body.removeChild(tempTextArea);
+            }
+
+            // 初始化工具提示
+            function initTooltips() {
+                var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+                tooltipTriggerList.map(function (tooltipTriggerEl) {
+                    return new bootstrap.Tooltip(tooltipTriggerEl);
+                });
+            }
+
+            // 添加显示文本
+            function addDisplayText() {
+                const textInput = document.getElementById("text-input");
+                const text = textInput.value.trim();
+
+                if (!text) {
+                    showMessage("请输入要显示的文本", "warning");
+                    log("添加显示文本失败：未输入文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加显示文本：未连接到服务器", "danger");
+                    log("添加显示文本失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在添加显示文本: ${text.substring(0, 20)}${text.length > 20 ? '...' : ''}`);
+
+                connection.invoke("AddDisplayList", text)
+                    .then(result => {
+                        log("显示文本添加成功");
+                        showMessage("文本已添加到显示队列", "success");
+
+                        // 清空输入框
+                        textInput.value = "";
+
+                        // 刷新右侧显示文本列表
+                        loadDisplayTextList();
+                    })
+                    .catch(err => {
+                        log(`添加显示文本失败: ${err}`);
+                        showMessage("添加显示文本失败", "danger");
+                    });
+            }
+
+            // 添加显示文本并从监控列表中移除
+            function addDisplayTextAndRemoveMonitor() {
+                const textInput = document.getElementById("text-input");
+                const text = textInput.value.trim();
+
+                // 获取当前选中的监控文本项
+                const selectedMonitorItem = document.querySelector("#monitor-text-list .list-group-item.active");
+
+                if (!text) {
+                    showMessage("请输入要显示的文本", "warning");
+                    log("添加并移除操作失败：未输入文本");
+                    return;
+                }
+
+                if (!selectedMonitorItem) {
+                    showMessage("请先从左侧列表选择一条文本记录", "warning");
+                    log("添加并移除操作失败：未选择监控文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加显示文本：未连接到服务器", "danger");
+                    log("添加显示文本失败：未连接到服务器");
+                    return;
+                }
+
+                const monitorTextId = selectedMonitorItem.dataset.id;
+
+                log(`正在添加显示文本并移除监控文本: ${text.substring(0, 20)}${text.length > 20 ? '...' : ''}, ID: ${monitorTextId}`);
+
+                // 先添加显示文本
+                connection.invoke("AddDisplayList", text)
+                    .then(result => {
+                        log("显示文本添加成功，正在删除监控文本");
+
+                        // 然后删除监控文本
+                        connection.invoke("DelMonitorText", monitorTextId)
+                            .then(delResult => {
+                                if (delResult) {
+                                    log("监控文本删除成功");
+
+                                    // 从UI中移除该项
+                                    selectedMonitorItem.remove();
+
+                                    // 清空输入框
+                                    textInput.value = "";
+
+                                    // 关闭文本显示
+                                    closeTextDisplay();
+
+                                    // 刷新右侧显示文本列表
+                                    loadDisplayTextList();
+
+                                    showMessage("文本已添加到显示队列并从监控列表移除", "success");
+                                } else {
+                                    log("监控文本删除失败");
+                                    showMessage("文本已添加到显示队列，但从监控列表移除失败", "warning");
+
+                                    // 刷新右侧显示文本列表
+                                    loadDisplayTextList();
+                                }
+                            })
+                            .catch(err => {
+                                log(`删除监控文本失败: ${err}`);
+                                showMessage("文本已添加到显示队列，但从监控列表移除失败", "warning");
+
+                                // 刷新右侧显示文本列表
+                                loadDisplayTextList();
+                            });
+                    })
+                    .catch(err => {
+                        log(`添加显示文本失败: ${err}`);
+                        showMessage("添加显示文本失败", "danger");
+                    });
+            }
+
+            // 获取服务器当前的音频流设置
+            function getServerAudioStreamingSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取音频流设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前音频流设置...");
+
+                connection.invoke("GetAudioStreamingSetting")
+                    .then(enabled => {
+                        log(`获取到服务器当前音频流设置: ${enabled ? "开启" : "关闭"}`);
+                        updateAudioStreamingUI(enabled);
+                        isAudioStreamEnabled = enabled;
+                    })
+                    .catch(err => {
+                        log("获取音频流设置失败: " + err);
+                    });
+            }
+
+            // 更新音频流设置UI
+            function updateAudioStreamingUI(enabled) {
+                // 更新单选按钮状态
+                document.getElementById(`audioStreaming${enabled ? 1 : 0}`).checked = true;
+
+                // 更新本地状态
+                isAudioStreamEnabled = enabled;
+
+                log(`UI音频流设置已更新为: ${enabled ? "开启" : "关闭"}`);
+            }
+
+            // 设置音量控制监听器
+            function setupVolumeControl() {
+                const volumeSlider = document.getElementById("volumeSlider");
+                if (volumeSlider) {
+                    // 初始化滑块值为当前音量 * 音量增益系数（转换为百分比）
+                    volumeSlider.value = Math.floor(currentVolume * 100);
+
+                    // 更新显示
+                    const volumeDisplay = document.getElementById("volumeDisplay");
+                    if (volumeDisplay) {
+                        volumeDisplay.textContent = `${Math.floor(currentVolume * 100)}%`;
+                    }
+
+                    // 监听音量变化
+                    volumeSlider.addEventListener("input", function () {
+                        const newVolume = parseFloat(this.value) / 100;
+                        currentVolume = newVolume;
+
+                        // 应用音量设置（包含增益）
+                        if (audioGainNode) {
+                            audioGainNode.gain.value = newVolume * volumeBoost;
+                        }
+
+                        // 更新显示
+                        if (volumeDisplay) {
+                            volumeDisplay.textContent = `${Math.floor(newVolume * 100)}%`;
+                        }
+
+                        log(`音量已调整: ${Math.floor(newVolume * 100)}%, 实际增益: ${(newVolume * volumeBoost).toFixed(1)}`);
+                    });
+                }
+            }
+
+            // 初始化音频上下文
+            function initAudioContext() {
+                try {
+                    // 关闭现有的音频上下文
+                    if (audioContext) {
+                        try {
+                            if (audioGainNode) {
+                                audioGainNode.disconnect();
+                                audioGainNode = null;
+                            }
+                            audioContext.close().catch(e => log("关闭音频上下文失败: " + e));
+                            audioContext = null;
+                        } catch (e) {
+                            log("重置音频上下文失败: " + e);
+                        }
+                    }
+
+                    // 创建新的音频上下文
+                    const AudioContext = window.AudioContext || window.webkitAudioContext;
+                    audioContext = new AudioContext({
+                        latencyHint: 'interactive' // 低延迟设置
+                    });
+
+                    // 创建增益节点并设置更高的音量
+                    audioGainNode = audioContext.createGain();
+                    audioGainNode.gain.value = currentVolume * volumeBoost; // 应用音量增益
+                    audioGainNode.connect(audioContext.destination);
+
+                    log(`音频上下文已初始化: 采样率=${audioContext.sampleRate}Hz, 状态=${audioContext.state}, 音量增益=${volumeBoost}倍`);
+
+                    // 恢复音频上下文
+                    if (audioContext.state === 'suspended') {
+                        const resumeAudio = function () {
+                            if (audioContext && audioContext.state === 'suspended') {
+                                audioContext.resume().then(() => {
+                                    log("音频上下文已激活");
+                                }).catch(err => {
+                                    log("激活音频上下文失败: " + err);
+                                });
+                            }
+                        };
+
+                        // 设置单次事件监听
+                        document.addEventListener('click', resumeAudio, { once: true });
+                        document.addEventListener('touchstart', resumeAudio, { once: true });
+                        document.addEventListener('keydown', resumeAudio, { once: true });
+
+                        // 尝试立即恢复
+                        resumeAudio();
+                    }
+                } catch (e) {
+                    log("初始化音频上下文失败: " + e);
+                    showMessage("无法初始化音频播放: " + e, "danger");
+                }
+            }
+
+            // 播放实时音频 - 适应新格式
+            function playRealTimeAudio(audioPacket) {
+                if (!audioContext || !isAudioStreamEnabled || !callInProgress) return;
+
+                try {
+                    // 解析音频元数据和数据
+                    const { format, sampleRate, channels, data } = audioPacket;
+
+                    // 确保格式正确
+                    if (!format || !data) {
+                        log("音频格式或数据无效");
+                        return;
+                    }
+
+                    log(`接收到音频数据: 格式=${format}, 采样率=${sampleRate}, 声道=${channels}, 数据长度=${Array.isArray(data) ? data.length : '未知'}`);
+
+                    // 根据不同的音频格式处理
+                    if (format === "WAV") {
+                        // 处理WAV格式数据 - 异步解码
+                        processWavData(data, sampleRate, channels)
+                            .then(audioBuffer => {
+                                if (audioBuffer) {
+                                    playAudioBuffer(audioBuffer);
+                                } else {
+                                    log("无法创建WAV音频缓冲区");
+                                }
+                            })
+                            .catch(err => {
+                                log("WAV处理错误: " + err);
+                            });
+                    } else if (format === "16bit_PCM") {
+                        // 处理PCM格式数据 - 同步处理
+                        const audioBuffer = processPcmData(data, sampleRate, channels);
+                        if (audioBuffer) {
+                            playAudioBuffer(audioBuffer);
+                        } else {
+                            log("无法创建PCM音频缓冲区");
+                        }
+                    } else {
+                        log("不支持的音频格式: " + format);
+                    }
+                } catch (e) {
+                    log("处理实时音频失败: " + e);
+                }
+            }
+
+            // 播放音频缓冲区
+            function playAudioBuffer(audioBuffer) {
+                // 确保音频上下文活跃
+                if (audioContext.state === 'suspended') {
+                    try {
+                        audioContext.resume();
+                    } catch (e) {
+                        log("恢复音频上下文失败: " + e);
+                        return;
+                    }
+                }
+
+                // 创建音频源并连接
+                const source = audioContext.createBufferSource();
+                source.buffer = audioBuffer;
+
+                // 应用音量控制
+                source.connect(audioGainNode);
+                if (audioGainNode) {
+                    audioGainNode.gain.value = currentVolume * volumeBoost;
+                }
+
+                // 立即播放
+                source.start(0);
+                log("开始播放音频");
+            }
+
+            // 处理WAV格式的数据 - 返回Promise
+            function processWavData(data, sampleRate, channels) {
+                return new Promise((resolve, reject) => {
+                    try {
+                        // 确保音频上下文存在
+                        if (!audioContext || audioContext.state === 'closed') {
+                            initAudioContext();
+                            if (!audioContext) {
+                                reject(new Error("无法初始化音频上下文"));
+                                return;
+                            }
+                        }
+
+                        // 将数据转换为ArrayBuffer
+                        let arrayBuffer;
+                        if (data instanceof Uint8Array) {
+                            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                        } else if (Array.isArray(data)) {
+                            // 转换数组为Uint8Array
+                            const uint8Array = new Uint8Array(data);
+                            arrayBuffer = uint8Array.buffer;
+                        } else if (typeof data === 'string') {
+                            // 处理Base64编码
+                            try {
+                                const base64Str = data.trim().replace(/^data:[^;]+;base64,/, '');
+                                const binary = atob(base64Str);
+                                const uint8Array = new Uint8Array(binary.length);
+                                for (let i = 0; i < binary.length; i++) {
+                                    uint8Array[i] = binary.charCodeAt(i);
+                                }
+                                arrayBuffer = uint8Array.buffer;
+                            } catch (e) {
+                                log("WAV数据Base64解码失败: " + e);
+                                reject(e);
+                                return;
+                            }
+                        } else if (data.buffer) {
+                            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                        } else {
+                            const error = new Error("无法处理的WAV数据类型");
+                            log(error.message);
+                            reject(error);
+                            return;
+                        }
+
+                        // 使用Web Audio API解码音频
+                        audioContext.decodeAudioData(
+                            arrayBuffer,
+                            (buffer) => {
+                                log("WAV数据解码成功, 时长: " + buffer.duration.toFixed(2) + "秒");
+                                resolve(buffer);
+                            },
+                            (err) => {
+                                log("解码WAV数据失败: " + err);
+                                reject(err);
+                            }
+                        );
+                    } catch (e) {
+                        log("处理WAV数据失败: " + e);
+                        reject(e);
+                    }
+                });
+            }
+
+            // 处理PCM格式的数据
+            function processPcmData(data, sampleRate, channels) {
+                try {
+                    // 确保音频上下文存在
+                    if (!audioContext || audioContext.state === 'closed') {
+                        initAudioContext();
+                        if (!audioContext) return null;
+                    }
+
+                    // 转换数据为适合的格式
+                    let pcmData;
+                    if (data instanceof Uint8Array) {
+                        pcmData = data;
+                    } else if (Array.isArray(data)) {
+                        pcmData = new Uint8Array(data);
+                    } else if (typeof data === 'object' && data.buffer) {
+                        pcmData = new Uint8Array(data.buffer);
+                    } else if (typeof data === 'string') {
+                        try {
+                            // 处理Base64编码
+                            const base64Str = data.trim().replace(/^data:[^;]+;base64,/, '');
+                            const binary = atob(base64Str);
+                            pcmData = new Uint8Array(binary.length);
+                            for (let i = 0; i < binary.length; i++) {
+                                pcmData[i] = binary.charCodeAt(i);
+                            }
+                        } catch (e) {
+                            log("PCM数据Base64解码失败: " + e);
+                            return null;
+                        }
+                    } else {
+                        log("不支持的PCM数据类型");
+                        return null;
+                    }
+
+                    // 确保有效的数据
+                    if (!pcmData || pcmData.length < 2) {
+                        log("PCM数据无效或太短");
+                        return null;
+                    }
+
+                    // 确保数据长度是偶数（16位PCM）
+                    const validLength = Math.floor(pcmData.length / 2) * 2;
+                    if (validLength < pcmData.length) {
+                        pcmData = pcmData.slice(0, validLength);
+                    }
+
+                    try {
+                        // 从Uint8Array创建Int16Array视图
+                        let int16Data;
+
+                        try {
+                            // 创建DataView以便正确解析16位整数
+                            const dataView = new DataView(pcmData.buffer, pcmData.byteOffset, pcmData.byteLength);
+                            int16Data = new Int16Array(pcmData.length / 2);
+
+                            // 从小端字节序读取16位整数
+                            for (let i = 0; i < pcmData.length; i += 2) {
+                                if (i + 1 < pcmData.length) {
+                                    int16Data[i / 2] = dataView.getInt16(i, true); // true表示小端字节序
+                                }
+                            }
+                        } catch (e) {
+                            log("创建Int16Array失败: " + e);
+
+                            // 备用方法
+                            const newBuffer = new ArrayBuffer(pcmData.length);
+                            const newView = new Uint8Array(newBuffer);
+                            newView.set(pcmData);
+                            const dataView = new DataView(newBuffer);
+
+                            int16Data = new Int16Array(pcmData.length / 2);
+                            for (let i = 0; i < pcmData.length; i += 2) {
+                                if (i + 1 < pcmData.length) {
+                                    int16Data[i / 2] = dataView.getInt16(i, true);
+                                }
+                            }
+                        }
+
+                        // 创建音频缓冲区，使用实际采样率
+                        const audioSampleRate = sampleRate || audioContext.sampleRate;
+                        const buffer = audioContext.createBuffer(channels || 1, int16Data.length, audioSampleRate);
+
+                        // 将Int16数据转换为Float32数据并存入缓冲区
+                        const channelData = buffer.getChannelData(0);
+                        for (let i = 0; i < int16Data.length; i++) {
+                            // 将Int16转换为-1.0到1.0的Float32
+                            channelData[i] = Math.max(-1, Math.min(1, int16Data[i] / 32768.0));
+                        }
+
+                        return buffer;
+                    } catch (e) {
+                        log("PCM数据处理失败: " + e);
+                        return null;
+                    }
+                } catch (e) {
+                    log("处理PCM数据失败: " + e);
+                    return null;
+                }
+            }
+
+            // 显示实时语音识别结果
+            function showRealtimeTextResult(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容，添加一个标记表明这是实时结果
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.innerHTML = `<span class="realtime-text" style="color: #0d6efd;">${text}</span> <small class="text-muted">(实时识别中...)</small>`;
+
+                log("显示实时语音识别结果");
+            }
+
+            // 显示最终语音识别结果
+            function showFinalTextResult(text) {
+                // 显示文本区域
+                const textDisplayArea = document.getElementById("text-display-area");
+                textDisplayArea.style.display = "block";
+
+                // 设置文本内容，并标记为最终结果
+                const displayedText = document.getElementById("displayed-text");
+                displayedText.innerHTML = `<span class="final-text">${text}</span>`;
+
+                log("显示最终语音识别结果");
+            }
+
+            // 添加文本到监控列表
+            function addToMonitorList(text) {
+                if (!text || text.trim() === "") return;
+
+                // 检查是否已经存在相同内容
+                const existingItems = document.querySelectorAll("#monitor-text-list .list-group-item");
+                for (let i = 0; i < existingItems.length; i++) {
+                    if (existingItems[i].dataset.fullText === text) {
+                        // 已存在相同内容，不需要添加
+                        return;
+                    }
+                }
+
+                // 创建新的列表项
+                const container = document.getElementById("monitor-text-list");
+                const listItem = document.createElement("div");
+                listItem.className = "list-group-item";
+                // 使用临时ID，服务器端会分配真正的ID
+                listItem.dataset.id = "temp-" + Date.now();
+                listItem.dataset.fullText = text;
+
+                // 添加点击事件
+                listItem.addEventListener('click', function (e) {
+                    // 如果点击的是按钮，不触发选择
+                    if (e.target.tagName === 'BUTTON' || e.target.tagName === 'I' ||
+                        e.target.closest('button')) {
+                        return;
+                    }
+
+                    // 移除其他项的active类
+                    document.querySelectorAll("#monitor-text-list .list-group-item").forEach(item => {
+                        item.classList.remove("active");
+                    });
+
+                    // 添加active类到当前项
+                    this.classList.add("active");
+
+                    // 显示文本
+                    displayTextInCenter(this.dataset.fullText);
+                });
+
+                // 获取当前时间
+                const date = new Date();
+                const formattedDate = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
+
+                // 截取前10个字符，若不足10个则全部显示
+                const shortText = text.length > 10 ? text.substring(0, 10) : text;
+
+                listItem.innerHTML = `
+                                                                <div class="d-flex justify-content-between align-items-start mb-1">
+                                                                    <small class="text-muted">【${shortText}】</small>
+                                                                    <div class="btn-group btn-group-sm">
+                                                                        <button class="btn btn-outline-danger btn-sm" onclick="deleteMonitorText('${listItem.dataset.id}')">
+                                                                            <i class="bi bi-trash"></i>
+                                                                        </button>
+                                                                    </div>
+                                                                </div>
+                                                                <div>${formattedDate} (本地)</div>
+                                                            `;
+
+                // 添加到列表顶部
+                if (container.firstChild) {
+                    container.insertBefore(listItem, container.firstChild);
+                } else {
+                    container.appendChild(listItem);
+                }
+
+                log(`已添加文本到监控列表: ${shortText}...`);
+            }
+
+            // 更新控屏UI
+            function updateScreenControlUI(isManual) {
+                // 更新单选按钮状态
+                document.getElementById(isManual ? 'screenControlManual' : 'screenControlAuto').checked = true;
+                isManualScreenControl = isManual;
+
+                log(`UI控屏模式已更新为: ${isManual ? "手动" : "自动"}`);
+            }
+
+            // 获取服务器当前的控屏设置
+            function getServerScreenControlSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取控屏设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前控屏设置...");
+
+                connection.invoke("GetScreenControlSetting")
+                    .then(isManual => {
+                        log(`获取到服务器控屏设置: ${isManual ? "手动" : "自动"}`);
+                        updateScreenControlUI(isManual);
+                    })
+                    .catch(err => {
+                        log(`获取控屏设置失败: ${err}`);
+                        // 默认设置为自动
+                        updateScreenControlUI(false);
+                    });
+            }
+
+            // 初始化UI和事件
+            function initUI() {
+                // 查询当前选择的模式
+                if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                    // 获取当前控屏设置
+                    getServerScreenControlSetting();
+
+                    // 获取当前音频流设置
+                    getServerAudioStreamingSetting();
+
+                       // 获取当前预设句子类型设置
+                    getServerPresetSentenceTypeSetting();
+                }
+
+                // 设置工具提示
+                var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+                tooltipTriggerList.map(function (tooltipTriggerEl) {
+                    return new bootstrap.Tooltip(tooltipTriggerEl);
+                });
+            }
+
+            // 获取服务器当前预设句子类型设置
+            function getServerPresetSentenceTypeSetting() {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    log("无法获取预设句子类型设置：未连接");
+                    return;
+                }
+
+                log("获取服务器当前预设句子类型设置...");
+
+                connection.invoke("GetPresetSentenceType")
+                    .then(type => {
+                        log(`获取到服务器当前预设句子类型设置: ${type}`);
+                        updatePresetSentenceTypeUI(type);
+                    })
+                    .catch(err => {
+                        log("获取预设句子类型设置失败: " + err);
+                    });
+            }
+
+            // 更新预设句子类型UI
+            function updatePresetSentenceTypeUI(type) {
+                // 更新单选按钮状态
+                document.getElementById(`presetSentenceType${type}`).checked = true;
+                log(`UI预设句子类型设置已更新为: ${type}`);
+            }
+
+            // 更新预设句子类型
+            function updatePresetSentenceType(type) {
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法更新预设句子类型：未连接到服务器", "danger");
+                    log("更新预设句子类型失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在更新预设句子类型: ${type}`);
+
+                connection.invoke("UpdatePresetSentenceType", type)
+                    .then(result => {
+                        if (result) {
+                            log("预设句子类型更新成功");
+                            showMessage(`预设句子类型已更新为: ${type === 0 ? '默认预设句子' : '预设句子2'}`, "success");
+                        } else {
+                            log("预设句子类型更新失败");
+                            showMessage("预设句子类型更新失败", "danger");
+                        }
+                    })
+                    .catch(err => {
+                        log(`更新预设句子类型失败: ${err}`);
+                        showMessage("更新预设句子类型失败", "danger");
+                    });
+            }
+
+            // 添加预设句子
+            function addPresetSentence() {
+                const sentenceInput = document.getElementById("presetSentenceInput");
+                const text = sentenceInput.value.trim();
+
+                if (!text) {
+                    showMessage("请输入要添加的预设句子", "warning");
+                    log("添加预设句子失败：未输入文本");
+                    return;
+                }
+
+                if (!connection || connection.state !== signalR.HubConnectionState.Connected) {
+                    showMessage("无法添加预设句子：未连接到服务器", "danger");
+                    log("添加预设句子失败：未连接到服务器");
+                    return;
+                }
+
+                log(`正在添加预设句子: ${text}`);
+
+                connection.invoke("AddPresetSentence", text)
+                    .then(result => {
+                        if (result) {
+                            log("预设句子添加成功");
+                            showMessage("预设句子已添加", "success");
+                            // 清空输入框
+                            sentenceInput.value = "";
+                        } else {
+                            log("预设句子添加失败");
+                            showMessage("预设句子添加失败", "danger");
+                        }
+                    })
+                    .catch(err => {
+                        log(`添加预设句子失败: ${err}`);
+                        showMessage("添加预设句子失败", "danger");
+                    });
+            }
+
+            // 添加监听器：预设句子类型已更改
+            function setupPresetSentenceTypeListeners() {
+                connection.on("PresetSentenceTypeChanged", function (type) {
+                    log(`收到预设句子类型更改通知: ${type}`);
+                    updatePresetSentenceTypeUI(type);
+                });
+
+                connection.on("PresetSentencesUpdated", function () {
+                    log("收到预设句子更新通知");
+                    showMessage("预设句子列表已更新", "info");
+                });
+            }
+
+            // 启动连接
+            async function start() {
+                try {
+                    if (connection && connection.state === signalR.HubConnectionState.Connected) {
+                        log("已经连接到Hub，无需重新连接");
+                        return;
+                    }
+                    debugger
+                    if (!connection) {
+                        log("初始化SignalR连接...");
+
+                        // 创建连接
+                        connection = new signalR.HubConnectionBuilder()
+                            .withUrl("/audiohub")
+                            .withAutomaticReconnect()
+                            .build();
+
+                        // 设置连接事件监听
+                        setupConnectionEventHandlers();
+
+                        // 设置消息接收处理器
+                        setupMessageHandlers();
+
+                        // 设置控屏设置变更监听器
+                        setupScreenControlListeners();
+
+                        // 设置音频流设置变更监听器
+                        setupAudioStreamingListeners();
+
+                        // 设置预设句子类型变更监听器
+                        setupPresetSentenceTypeListeners();
+                    }
+
+                    log("正在连接到Hub...");
+                    await connection.start();
+                    log("成功连接到Hub");
+
+                    // 注册为监控客户端
+                    await connection.invoke("RegisterClient", "monitor");
+                    log("已注册为监控客户端");
+
+                    // 加载文本列表
+                    loadTextLists();
+
+                    // 初始化音频上下文
+                    initAudioContext();
+
+                    // 启用实时音频流
+                    isAudioStreamEnabled = true;
+
+                    // 初始化UI和事件
+                    initUI();
+
+                } catch (err) {
+                    log(`连接失败：${err}`);
+                    setTimeout(start, 5000); // 5秒后重试
+                }
+            }
+        </script>
+    }
diff --git a/ShengShengBuXi/wwwroot/css/bootstrap-icons.css b/ShengShengBuXi/wwwroot/css/bootstrap-icons.css
new file mode 100644
index 0000000..8bda018
--- /dev/null
+++ b/ShengShengBuXi/wwwroot/css/bootstrap-icons.css
@@ -0,0 +1,1981 @@
+/*!
+ * Bootstrap Icons v1.10.5 (https://icons.getbootstrap.com/)
+ * Copyright 2019-2023 The Bootstrap Authors
+ * Licensed under MIT (https://github.com/twbs/icons/blob/main/LICENSE)
+ */
+
+@font-face {
+  font-display: block;
+  font-family: "bootstrap-icons";
+  src: url("./fonts/bootstrap-icons.woff2?1fa40e8900654d2863d011707b9fb6f2") format("woff2"),
+url("./fonts/bootstrap-icons.woff?1fa40e8900654d2863d011707b9fb6f2") format("woff");
+}
+
+.bi::before,
+[class^="bi-"]::before,
+[class*=" bi-"]::before {
+  display: inline-block;
+  font-family: bootstrap-icons !important;
+  font-style: normal;
+  font-weight: normal !important;
+  font-variant: normal;
+  text-transform: none;
+  line-height: 1;
+  vertical-align: -.125em;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+.bi-123::before { content: "\f67f"; }
+.bi-alarm-fill::before { content: "\f101"; }
+.bi-alarm::before { content: "\f102"; }
+.bi-align-bottom::before { content: "\f103"; }
+.bi-align-center::before { content: "\f104"; }
+.bi-align-end::before { content: "\f105"; }
+.bi-align-middle::before { content: "\f106"; }
+.bi-align-start::before { content: "\f107"; }
+.bi-align-top::before { content: "\f108"; }
+.bi-alt::before { content: "\f109"; }
+.bi-app-indicator::before { content: "\f10a"; }
+.bi-app::before { content: "\f10b"; }
+.bi-archive-fill::before { content: "\f10c"; }
+.bi-archive::before { content: "\f10d"; }
+.bi-arrow-90deg-down::before { content: "\f10e"; }
+.bi-arrow-90deg-left::before { content: "\f10f"; }
+.bi-arrow-90deg-right::before { content: "\f110"; }
+.bi-arrow-90deg-up::before { content: "\f111"; }
+.bi-arrow-bar-down::before { content: "\f112"; }
+.bi-arrow-bar-left::before { content: "\f113"; }
+.bi-arrow-bar-right::before { content: "\f114"; }
+.bi-arrow-bar-up::before { content: "\f115"; }
+.bi-arrow-clockwise::before { content: "\f116"; }
+.bi-arrow-counterclockwise::before { content: "\f117"; }
+.bi-arrow-down-circle-fill::before { content: "\f118"; }
+.bi-arrow-down-circle::before { content: "\f119"; }
+.bi-arrow-down-left-circle-fill::before { content: "\f11a"; }
+.bi-arrow-down-left-circle::before { content: "\f11b"; }
+.bi-arrow-down-left-square-fill::before { content: "\f11c"; }
+.bi-arrow-down-left-square::before { content: "\f11d"; }
+.bi-arrow-down-left::before { content: "\f11e"; }
+.bi-arrow-down-right-circle-fill::before { content: "\f11f"; }
+.bi-arrow-down-right-circle::before { content: "\f120"; }
+.bi-arrow-down-right-square-fill::before { content: "\f121"; }
+.bi-arrow-down-right-square::before { content: "\f122"; }
+.bi-arrow-down-right::before { content: "\f123"; }
+.bi-arrow-down-short::before { content: "\f124"; }
+.bi-arrow-down-square-fill::before { content: "\f125"; }
+.bi-arrow-down-square::before { content: "\f126"; }
+.bi-arrow-down-up::before { content: "\f127"; }
+.bi-arrow-down::before { content: "\f128"; }
+.bi-arrow-left-circle-fill::before { content: "\f129"; }
+.bi-arrow-left-circle::before { content: "\f12a"; }
+.bi-arrow-left-right::before { content: "\f12b"; }
+.bi-arrow-left-short::before { content: "\f12c"; }
+.bi-arrow-left-square-fill::before { content: "\f12d"; }
+.bi-arrow-left-square::before { content: "\f12e"; }
+.bi-arrow-left::before { content: "\f12f"; }
+.bi-arrow-repeat::before { content: "\f130"; }
+.bi-arrow-return-left::before { content: "\f131"; }
+.bi-arrow-return-right::before { content: "\f132"; }
+.bi-arrow-right-circle-fill::before { content: "\f133"; }
+.bi-arrow-right-circle::before { content: "\f134"; }
+.bi-arrow-right-short::before { content: "\f135"; }
+.bi-arrow-right-square-fill::before { content: "\f136"; }
+.bi-arrow-right-square::before { content: "\f137"; }
+.bi-arrow-right::before { content: "\f138"; }
+.bi-arrow-up-circle-fill::before { content: "\f139"; }
+.bi-arrow-up-circle::before { content: "\f13a"; }
+.bi-arrow-up-left-circle-fill::before { content: "\f13b"; }
+.bi-arrow-up-left-circle::before { content: "\f13c"; }
+.bi-arrow-up-left-square-fill::before { content: "\f13d"; }
+.bi-arrow-up-left-square::before { content: "\f13e"; }
+.bi-arrow-up-left::before { content: "\f13f"; }
+.bi-arrow-up-right-circle-fill::before { content: "\f140"; }
+.bi-arrow-up-right-circle::before { content: "\f141"; }
+.bi-arrow-up-right-square-fill::before { content: "\f142"; }
+.bi-arrow-up-right-square::before { content: "\f143"; }
+.bi-arrow-up-right::before { content: "\f144"; }
+.bi-arrow-up-short::before { content: "\f145"; }
+.bi-arrow-up-square-fill::before { content: "\f146"; }
+.bi-arrow-up-square::before { content: "\f147"; }
+.bi-arrow-up::before { content: "\f148"; }
+.bi-arrows-angle-contract::before { content: "\f149"; }
+.bi-arrows-angle-expand::before { content: "\f14a"; }
+.bi-arrows-collapse::before { content: "\f14b"; }
+.bi-arrows-expand::before { content: "\f14c"; }
+.bi-arrows-fullscreen::before { content: "\f14d"; }
+.bi-arrows-move::before { content: "\f14e"; }
+.bi-aspect-ratio-fill::before { content: "\f14f"; }
+.bi-aspect-ratio::before { content: "\f150"; }
+.bi-asterisk::before { content: "\f151"; }
+.bi-at::before { content: "\f152"; }
+.bi-award-fill::before { content: "\f153"; }
+.bi-award::before { content: "\f154"; }
+.bi-back::before { content: "\f155"; }
+.bi-backspace-fill::before { content: "\f156"; }
+.bi-backspace-reverse-fill::before { content: "\f157"; }
+.bi-backspace-reverse::before { content: "\f158"; }
+.bi-backspace::before { content: "\f159"; }
+.bi-badge-3d-fill::before { content: "\f15a"; }
+.bi-badge-3d::before { content: "\f15b"; }
+.bi-badge-4k-fill::before { content: "\f15c"; }
+.bi-badge-4k::before { content: "\f15d"; }
+.bi-badge-8k-fill::before { content: "\f15e"; }
+.bi-badge-8k::before { content: "\f15f"; }
+.bi-badge-ad-fill::before { content: "\f160"; }
+.bi-badge-ad::before { content: "\f161"; }
+.bi-badge-ar-fill::before { content: "\f162"; }
+.bi-badge-ar::before { content: "\f163"; }
+.bi-badge-cc-fill::before { content: "\f164"; }
+.bi-badge-cc::before { content: "\f165"; }
+.bi-badge-hd-fill::before { content: "\f166"; }
+.bi-badge-hd::before { content: "\f167"; }
+.bi-badge-tm-fill::before { content: "\f168"; }
+.bi-badge-tm::before { content: "\f169"; }
+.bi-badge-vo-fill::before { content: "\f16a"; }
+.bi-badge-vo::before { content: "\f16b"; }
+.bi-badge-vr-fill::before { content: "\f16c"; }
+.bi-badge-vr::before { content: "\f16d"; }
+.bi-badge-wc-fill::before { content: "\f16e"; }
+.bi-badge-wc::before { content: "\f16f"; }
+.bi-bag-check-fill::before { content: "\f170"; }
+.bi-bag-check::before { content: "\f171"; }
+.bi-bag-dash-fill::before { content: "\f172"; }
+.bi-bag-dash::before { content: "\f173"; }
+.bi-bag-fill::before { content: "\f174"; }
+.bi-bag-plus-fill::before { content: "\f175"; }
+.bi-bag-plus::before { content: "\f176"; }
+.bi-bag-x-fill::before { content: "\f177"; }
+.bi-bag-x::before { content: "\f178"; }
+.bi-bag::before { content: "\f179"; }
+.bi-bar-chart-fill::before { content: "\f17a"; }
+.bi-bar-chart-line-fill::before { content: "\f17b"; }
+.bi-bar-chart-line::before { content: "\f17c"; }
+.bi-bar-chart-steps::before { content: "\f17d"; }
+.bi-bar-chart::before { content: "\f17e"; }
+.bi-basket-fill::before { content: "\f17f"; }
+.bi-basket::before { content: "\f180"; }
+.bi-basket2-fill::before { content: "\f181"; }
+.bi-basket2::before { content: "\f182"; }
+.bi-basket3-fill::before { content: "\f183"; }
+.bi-basket3::before { content: "\f184"; }
+.bi-battery-charging::before { content: "\f185"; }
+.bi-battery-full::before { content: "\f186"; }
+.bi-battery-half::before { content: "\f187"; }
+.bi-battery::before { content: "\f188"; }
+.bi-bell-fill::before { content: "\f189"; }
+.bi-bell::before { content: "\f18a"; }
+.bi-bezier::before { content: "\f18b"; }
+.bi-bezier2::before { content: "\f18c"; }
+.bi-bicycle::before { content: "\f18d"; }
+.bi-binoculars-fill::before { content: "\f18e"; }
+.bi-binoculars::before { content: "\f18f"; }
+.bi-blockquote-left::before { content: "\f190"; }
+.bi-blockquote-right::before { content: "\f191"; }
+.bi-book-fill::before { content: "\f192"; }
+.bi-book-half::before { content: "\f193"; }
+.bi-book::before { content: "\f194"; }
+.bi-bookmark-check-fill::before { content: "\f195"; }
+.bi-bookmark-check::before { content: "\f196"; }
+.bi-bookmark-dash-fill::before { content: "\f197"; }
+.bi-bookmark-dash::before { content: "\f198"; }
+.bi-bookmark-fill::before { content: "\f199"; }
+.bi-bookmark-heart-fill::before { content: "\f19a"; }
+.bi-bookmark-heart::before { content: "\f19b"; }
+.bi-bookmark-plus-fill::before { content: "\f19c"; }
+.bi-bookmark-plus::before { content: "\f19d"; }
+.bi-bookmark-star-fill::before { content: "\f19e"; }
+.bi-bookmark-star::before { content: "\f19f"; }
+.bi-bookmark-x-fill::before { content: "\f1a0"; }
+.bi-bookmark-x::before { content: "\f1a1"; }
+.bi-bookmark::before { content: "\f1a2"; }
+.bi-bookmarks-fill::before { content: "\f1a3"; }
+.bi-bookmarks::before { content: "\f1a4"; }
+.bi-bookshelf::before { content: "\f1a5"; }
+.bi-bootstrap-fill::before { content: "\f1a6"; }
+.bi-bootstrap-reboot::before { content: "\f1a7"; }
+.bi-bootstrap::before { content: "\f1a8"; }
+.bi-border-all::before { content: "\f1a9"; }
+.bi-border-bottom::before { content: "\f1aa"; }
+.bi-border-center::before { content: "\f1ab"; }
+.bi-border-inner::before { content: "\f1ac"; }
+.bi-border-left::before { content: "\f1ad"; }
+.bi-border-middle::before { content: "\f1ae"; }
+.bi-border-outer::before { content: "\f1af"; }
+.bi-border-right::before { content: "\f1b0"; }
+.bi-border-style::before { content: "\f1b1"; }
+.bi-border-top::before { content: "\f1b2"; }
+.bi-border-width::before { content: "\f1b3"; }
+.bi-border::before { content: "\f1b4"; }
+.bi-bounding-box-circles::before { content: "\f1b5"; }
+.bi-bounding-box::before { content: "\f1b6"; }
+.bi-box-arrow-down-left::before { content: "\f1b7"; }
+.bi-box-arrow-down-right::before { content: "\f1b8"; }
+.bi-box-arrow-down::before { content: "\f1b9"; }
+.bi-box-arrow-in-down-left::before { content: "\f1ba"; }
+.bi-box-arrow-in-down-right::before { content: "\f1bb"; }
+.bi-box-arrow-in-down::before { content: "\f1bc"; }
+.bi-box-arrow-in-left::before { content: "\f1bd"; }
+.bi-box-arrow-in-right::before { content: "\f1be"; }
+.bi-box-arrow-in-up-left::before { content: "\f1bf"; }
+.bi-box-arrow-in-up-right::before { content: "\f1c0"; }
+.bi-box-arrow-in-up::before { content: "\f1c1"; }
+.bi-box-arrow-left::before { content: "\f1c2"; }
+.bi-box-arrow-right::before { content: "\f1c3"; }
+.bi-box-arrow-up-left::before { content: "\f1c4"; }
+.bi-box-arrow-up-right::before { content: "\f1c5"; }
+.bi-box-arrow-up::before { content: "\f1c6"; }
+.bi-box-seam::before { content: "\f1c7"; }
+.bi-box::before { content: "\f1c8"; }
+.bi-braces::before { content: "\f1c9"; }
+.bi-bricks::before { content: "\f1ca"; }
+.bi-briefcase-fill::before { content: "\f1cb"; }
+.bi-briefcase::before { content: "\f1cc"; }
+.bi-brightness-alt-high-fill::before { content: "\f1cd"; }
+.bi-brightness-alt-high::before { content: "\f1ce"; }
+.bi-brightness-alt-low-fill::before { content: "\f1cf"; }
+.bi-brightness-alt-low::before { content: "\f1d0"; }
+.bi-brightness-high-fill::before { content: "\f1d1"; }
+.bi-brightness-high::before { content: "\f1d2"; }
+.bi-brightness-low-fill::before { content: "\f1d3"; }
+.bi-brightness-low::before { content: "\f1d4"; }
+.bi-broadcast-pin::before { content: "\f1d5"; }
+.bi-broadcast::before { content: "\f1d6"; }
+.bi-brush-fill::before { content: "\f1d7"; }
+.bi-brush::before { content: "\f1d8"; }
+.bi-bucket-fill::before { content: "\f1d9"; }
+.bi-bucket::before { content: "\f1da"; }
+.bi-bug-fill::before { content: "\f1db"; }
+.bi-bug::before { content: "\f1dc"; }
+.bi-building::before { content: "\f1dd"; }
+.bi-bullseye::before { content: "\f1de"; }
+.bi-calculator-fill::before { content: "\f1df"; }
+.bi-calculator::before { content: "\f1e0"; }
+.bi-calendar-check-fill::before { content: "\f1e1"; }
+.bi-calendar-check::before { content: "\f1e2"; }
+.bi-calendar-date-fill::before { content: "\f1e3"; }
+.bi-calendar-date::before { content: "\f1e4"; }
+.bi-calendar-day-fill::before { content: "\f1e5"; }
+.bi-calendar-day::before { content: "\f1e6"; }
+.bi-calendar-event-fill::before { content: "\f1e7"; }
+.bi-calendar-event::before { content: "\f1e8"; }
+.bi-calendar-fill::before { content: "\f1e9"; }
+.bi-calendar-minus-fill::before { content: "\f1ea"; }
+.bi-calendar-minus::before { content: "\f1eb"; }
+.bi-calendar-month-fill::before { content: "\f1ec"; }
+.bi-calendar-month::before { content: "\f1ed"; }
+.bi-calendar-plus-fill::before { content: "\f1ee"; }
+.bi-calendar-plus::before { content: "\f1ef"; }
+.bi-calendar-range-fill::before { content: "\f1f0"; }
+.bi-calendar-range::before { content: "\f1f1"; }
+.bi-calendar-week-fill::before { content: "\f1f2"; }
+.bi-calendar-week::before { content: "\f1f3"; }
+.bi-calendar-x-fill::before { content: "\f1f4"; }
+.bi-calendar-x::before { content: "\f1f5"; }
+.bi-calendar::before { content: "\f1f6"; }
+.bi-calendar2-check-fill::before { content: "\f1f7"; }
+.bi-calendar2-check::before { content: "\f1f8"; }
+.bi-calendar2-date-fill::before { content: "\f1f9"; }
+.bi-calendar2-date::before { content: "\f1fa"; }
+.bi-calendar2-day-fill::before { content: "\f1fb"; }
+.bi-calendar2-day::before { content: "\f1fc"; }
+.bi-calendar2-event-fill::before { content: "\f1fd"; }
+.bi-calendar2-event::before { content: "\f1fe"; }
+.bi-calendar2-fill::before { content: "\f1ff"; }
+.bi-calendar2-minus-fill::before { content: "\f200"; }
+.bi-calendar2-minus::before { content: "\f201"; }
+.bi-calendar2-month-fill::before { content: "\f202"; }
+.bi-calendar2-month::before { content: "\f203"; }
+.bi-calendar2-plus-fill::before { content: "\f204"; }
+.bi-calendar2-plus::before { content: "\f205"; }
+.bi-calendar2-range-fill::before { content: "\f206"; }
+.bi-calendar2-range::before { content: "\f207"; }
+.bi-calendar2-week-fill::before { content: "\f208"; }
+.bi-calendar2-week::before { content: "\f209"; }
+.bi-calendar2-x-fill::before { content: "\f20a"; }
+.bi-calendar2-x::before { content: "\f20b"; }
+.bi-calendar2::before { content: "\f20c"; }
+.bi-calendar3-event-fill::before { content: "\f20d"; }
+.bi-calendar3-event::before { content: "\f20e"; }
+.bi-calendar3-fill::before { content: "\f20f"; }
+.bi-calendar3-range-fill::before { content: "\f210"; }
+.bi-calendar3-range::before { content: "\f211"; }
+.bi-calendar3-week-fill::before { content: "\f212"; }
+.bi-calendar3-week::before { content: "\f213"; }
+.bi-calendar3::before { content: "\f214"; }
+.bi-calendar4-event::before { content: "\f215"; }
+.bi-calendar4-range::before { content: "\f216"; }
+.bi-calendar4-week::before { content: "\f217"; }
+.bi-calendar4::before { content: "\f218"; }
+.bi-camera-fill::before { content: "\f219"; }
+.bi-camera-reels-fill::before { content: "\f21a"; }
+.bi-camera-reels::before { content: "\f21b"; }
+.bi-camera-video-fill::before { content: "\f21c"; }
+.bi-camera-video-off-fill::before { content: "\f21d"; }
+.bi-camera-video-off::before { content: "\f21e"; }
+.bi-camera-video::before { content: "\f21f"; }
+.bi-camera::before { content: "\f220"; }
+.bi-camera2::before { content: "\f221"; }
+.bi-capslock-fill::before { content: "\f222"; }
+.bi-capslock::before { content: "\f223"; }
+.bi-card-checklist::before { content: "\f224"; }
+.bi-card-heading::before { content: "\f225"; }
+.bi-card-image::before { content: "\f226"; }
+.bi-card-list::before { content: "\f227"; }
+.bi-card-text::before { content: "\f228"; }
+.bi-caret-down-fill::before { content: "\f229"; }
+.bi-caret-down-square-fill::before { content: "\f22a"; }
+.bi-caret-down-square::before { content: "\f22b"; }
+.bi-caret-down::before { content: "\f22c"; }
+.bi-caret-left-fill::before { content: "\f22d"; }
+.bi-caret-left-square-fill::before { content: "\f22e"; }
+.bi-caret-left-square::before { content: "\f22f"; }
+.bi-caret-left::before { content: "\f230"; }
+.bi-caret-right-fill::before { content: "\f231"; }
+.bi-caret-right-square-fill::before { content: "\f232"; }
+.bi-caret-right-square::before { content: "\f233"; }
+.bi-caret-right::before { content: "\f234"; }
+.bi-caret-up-fill::before { content: "\f235"; }
+.bi-caret-up-square-fill::before { content: "\f236"; }
+.bi-caret-up-square::before { content: "\f237"; }
+.bi-caret-up::before { content: "\f238"; }
+.bi-cart-check-fill::before { content: "\f239"; }
+.bi-cart-check::before { content: "\f23a"; }
+.bi-cart-dash-fill::before { content: "\f23b"; }
+.bi-cart-dash::before { content: "\f23c"; }
+.bi-cart-fill::before { content: "\f23d"; }
+.bi-cart-plus-fill::before { content: "\f23e"; }
+.bi-cart-plus::before { content: "\f23f"; }
+.bi-cart-x-fill::before { content: "\f240"; }
+.bi-cart-x::before { content: "\f241"; }
+.bi-cart::before { content: "\f242"; }
+.bi-cart2::before { content: "\f243"; }
+.bi-cart3::before { content: "\f244"; }
+.bi-cart4::before { content: "\f245"; }
+.bi-cash-stack::before { content: "\f246"; }
+.bi-cash::before { content: "\f247"; }
+.bi-cast::before { content: "\f248"; }
+.bi-chat-dots-fill::before { content: "\f249"; }
+.bi-chat-dots::before { content: "\f24a"; }
+.bi-chat-fill::before { content: "\f24b"; }
+.bi-chat-left-dots-fill::before { content: "\f24c"; }
+.bi-chat-left-dots::before { content: "\f24d"; }
+.bi-chat-left-fill::before { content: "\f24e"; }
+.bi-chat-left-quote-fill::before { content: "\f24f"; }
+.bi-chat-left-quote::before { content: "\f250"; }
+.bi-chat-left-text-fill::before { content: "\f251"; }
+.bi-chat-left-text::before { content: "\f252"; }
+.bi-chat-left::before { content: "\f253"; }
+.bi-chat-quote-fill::before { content: "\f254"; }
+.bi-chat-quote::before { content: "\f255"; }
+.bi-chat-right-dots-fill::before { content: "\f256"; }
+.bi-chat-right-dots::before { content: "\f257"; }
+.bi-chat-right-fill::before { content: "\f258"; }
+.bi-chat-right-quote-fill::before { content: "\f259"; }
+.bi-chat-right-quote::before { content: "\f25a"; }
+.bi-chat-right-text-fill::before { content: "\f25b"; }
+.bi-chat-right-text::before { content: "\f25c"; }
+.bi-chat-right::before { content: "\f25d"; }
+.bi-chat-square-dots-fill::before { content: "\f25e"; }
+.bi-chat-square-dots::before { content: "\f25f"; }
+.bi-chat-square-fill::before { content: "\f260"; }
+.bi-chat-square-quote-fill::before { content: "\f261"; }
+.bi-chat-square-quote::before { content: "\f262"; }
+.bi-chat-square-text-fill::before { content: "\f263"; }
+.bi-chat-square-text::before { content: "\f264"; }
+.bi-chat-square::before { content: "\f265"; }
+.bi-chat-text-fill::before { content: "\f266"; }
+.bi-chat-text::before { content: "\f267"; }
+.bi-chat::before { content: "\f268"; }
+.bi-check-all::before { content: "\f269"; }
+.bi-check-circle-fill::before { content: "\f26a"; }
+.bi-check-circle::before { content: "\f26b"; }
+.bi-check-square-fill::before { content: "\f26c"; }
+.bi-check-square::before { content: "\f26d"; }
+.bi-check::before { content: "\f26e"; }
+.bi-check2-all::before { content: "\f26f"; }
+.bi-check2-circle::before { content: "\f270"; }
+.bi-check2-square::before { content: "\f271"; }
+.bi-check2::before { content: "\f272"; }
+.bi-chevron-bar-contract::before { content: "\f273"; }
+.bi-chevron-bar-down::before { content: "\f274"; }
+.bi-chevron-bar-expand::before { content: "\f275"; }
+.bi-chevron-bar-left::before { content: "\f276"; }
+.bi-chevron-bar-right::before { content: "\f277"; }
+.bi-chevron-bar-up::before { content: "\f278"; }
+.bi-chevron-compact-down::before { content: "\f279"; }
+.bi-chevron-compact-left::before { content: "\f27a"; }
+.bi-chevron-compact-right::before { content: "\f27b"; }
+.bi-chevron-compact-up::before { content: "\f27c"; }
+.bi-chevron-contract::before { content: "\f27d"; }
+.bi-chevron-double-down::before { content: "\f27e"; }
+.bi-chevron-double-left::before { content: "\f27f"; }
+.bi-chevron-double-right::before { content: "\f280"; }
+.bi-chevron-double-up::before { content: "\f281"; }
+.bi-chevron-down::before { content: "\f282"; }
+.bi-chevron-expand::before { content: "\f283"; }
+.bi-chevron-left::before { content: "\f284"; }
+.bi-chevron-right::before { content: "\f285"; }
+.bi-chevron-up::before { content: "\f286"; }
+.bi-circle-fill::before { content: "\f287"; }
+.bi-circle-half::before { content: "\f288"; }
+.bi-circle-square::before { content: "\f289"; }
+.bi-circle::before { content: "\f28a"; }
+.bi-clipboard-check::before { content: "\f28b"; }
+.bi-clipboard-data::before { content: "\f28c"; }
+.bi-clipboard-minus::before { content: "\f28d"; }
+.bi-clipboard-plus::before { content: "\f28e"; }
+.bi-clipboard-x::before { content: "\f28f"; }
+.bi-clipboard::before { content: "\f290"; }
+.bi-clock-fill::before { content: "\f291"; }
+.bi-clock-history::before { content: "\f292"; }
+.bi-clock::before { content: "\f293"; }
+.bi-cloud-arrow-down-fill::before { content: "\f294"; }
+.bi-cloud-arrow-down::before { content: "\f295"; }
+.bi-cloud-arrow-up-fill::before { content: "\f296"; }
+.bi-cloud-arrow-up::before { content: "\f297"; }
+.bi-cloud-check-fill::before { content: "\f298"; }
+.bi-cloud-check::before { content: "\f299"; }
+.bi-cloud-download-fill::before { content: "\f29a"; }
+.bi-cloud-download::before { content: "\f29b"; }
+.bi-cloud-drizzle-fill::before { content: "\f29c"; }
+.bi-cloud-drizzle::before { content: "\f29d"; }
+.bi-cloud-fill::before { content: "\f29e"; }
+.bi-cloud-fog-fill::before { content: "\f29f"; }
+.bi-cloud-fog::before { content: "\f2a0"; }
+.bi-cloud-fog2-fill::before { content: "\f2a1"; }
+.bi-cloud-fog2::before { content: "\f2a2"; }
+.bi-cloud-hail-fill::before { content: "\f2a3"; }
+.bi-cloud-hail::before { content: "\f2a4"; }
+.bi-cloud-haze-fill::before { content: "\f2a6"; }
+.bi-cloud-haze::before { content: "\f2a7"; }
+.bi-cloud-haze2-fill::before { content: "\f2a8"; }
+.bi-cloud-lightning-fill::before { content: "\f2a9"; }
+.bi-cloud-lightning-rain-fill::before { content: "\f2aa"; }
+.bi-cloud-lightning-rain::before { content: "\f2ab"; }
+.bi-cloud-lightning::before { content: "\f2ac"; }
+.bi-cloud-minus-fill::before { content: "\f2ad"; }
+.bi-cloud-minus::before { content: "\f2ae"; }
+.bi-cloud-moon-fill::before { content: "\f2af"; }
+.bi-cloud-moon::before { content: "\f2b0"; }
+.bi-cloud-plus-fill::before { content: "\f2b1"; }
+.bi-cloud-plus::before { content: "\f2b2"; }
+.bi-cloud-rain-fill::before { content: "\f2b3"; }
+.bi-cloud-rain-heavy-fill::before { content: "\f2b4"; }
+.bi-cloud-rain-heavy::before { content: "\f2b5"; }
+.bi-cloud-rain::before { content: "\f2b6"; }
+.bi-cloud-slash-fill::before { content: "\f2b7"; }
+.bi-cloud-slash::before { content: "\f2b8"; }
+.bi-cloud-sleet-fill::before { content: "\f2b9"; }
+.bi-cloud-sleet::before { content: "\f2ba"; }
+.bi-cloud-snow-fill::before { content: "\f2bb"; }
+.bi-cloud-snow::before { content: "\f2bc"; }
+.bi-cloud-sun-fill::before { content: "\f2bd"; }
+.bi-cloud-sun::before { content: "\f2be"; }
+.bi-cloud-upload-fill::before { content: "\f2bf"; }
+.bi-cloud-upload::before { content: "\f2c0"; }
+.bi-cloud::before { content: "\f2c1"; }
+.bi-clouds-fill::before { content: "\f2c2"; }
+.bi-clouds::before { content: "\f2c3"; }
+.bi-cloudy-fill::before { content: "\f2c4"; }
+.bi-cloudy::before { content: "\f2c5"; }
+.bi-code-slash::before { content: "\f2c6"; }
+.bi-code-square::before { content: "\f2c7"; }
+.bi-code::before { content: "\f2c8"; }
+.bi-collection-fill::before { content: "\f2c9"; }
+.bi-collection-play-fill::before { content: "\f2ca"; }
+.bi-collection-play::before { content: "\f2cb"; }
+.bi-collection::before { content: "\f2cc"; }
+.bi-columns-gap::before { content: "\f2cd"; }
+.bi-columns::before { content: "\f2ce"; }
+.bi-command::before { content: "\f2cf"; }
+.bi-compass-fill::before { content: "\f2d0"; }
+.bi-compass::before { content: "\f2d1"; }
+.bi-cone-striped::before { content: "\f2d2"; }
+.bi-cone::before { content: "\f2d3"; }
+.bi-controller::before { content: "\f2d4"; }
+.bi-cpu-fill::before { content: "\f2d5"; }
+.bi-cpu::before { content: "\f2d6"; }
+.bi-credit-card-2-back-fill::before { content: "\f2d7"; }
+.bi-credit-card-2-back::before { content: "\f2d8"; }
+.bi-credit-card-2-front-fill::before { content: "\f2d9"; }
+.bi-credit-card-2-front::before { content: "\f2da"; }
+.bi-credit-card-fill::before { content: "\f2db"; }
+.bi-credit-card::before { content: "\f2dc"; }
+.bi-crop::before { content: "\f2dd"; }
+.bi-cup-fill::before { content: "\f2de"; }
+.bi-cup-straw::before { content: "\f2df"; }
+.bi-cup::before { content: "\f2e0"; }
+.bi-cursor-fill::before { content: "\f2e1"; }
+.bi-cursor-text::before { content: "\f2e2"; }
+.bi-cursor::before { content: "\f2e3"; }
+.bi-dash-circle-dotted::before { content: "\f2e4"; }
+.bi-dash-circle-fill::before { content: "\f2e5"; }
+.bi-dash-circle::before { content: "\f2e6"; }
+.bi-dash-square-dotted::before { content: "\f2e7"; }
+.bi-dash-square-fill::before { content: "\f2e8"; }
+.bi-dash-square::before { content: "\f2e9"; }
+.bi-dash::before { content: "\f2ea"; }
+.bi-diagram-2-fill::before { content: "\f2eb"; }
+.bi-diagram-2::before { content: "\f2ec"; }
+.bi-diagram-3-fill::before { content: "\f2ed"; }
+.bi-diagram-3::before { content: "\f2ee"; }
+.bi-diamond-fill::before { content: "\f2ef"; }
+.bi-diamond-half::before { content: "\f2f0"; }
+.bi-diamond::before { content: "\f2f1"; }
+.bi-dice-1-fill::before { content: "\f2f2"; }
+.bi-dice-1::before { content: "\f2f3"; }
+.bi-dice-2-fill::before { content: "\f2f4"; }
+.bi-dice-2::before { content: "\f2f5"; }
+.bi-dice-3-fill::before { content: "\f2f6"; }
+.bi-dice-3::before { content: "\f2f7"; }
+.bi-dice-4-fill::before { content: "\f2f8"; }
+.bi-dice-4::before { content: "\f2f9"; }
+.bi-dice-5-fill::before { content: "\f2fa"; }
+.bi-dice-5::before { content: "\f2fb"; }
+.bi-dice-6-fill::before { content: "\f2fc"; }
+.bi-dice-6::before { content: "\f2fd"; }
+.bi-disc-fill::before { content: "\f2fe"; }
+.bi-disc::before { content: "\f2ff"; }
+.bi-discord::before { content: "\f300"; }
+.bi-display-fill::before { content: "\f301"; }
+.bi-display::before { content: "\f302"; }
+.bi-distribute-horizontal::before { content: "\f303"; }
+.bi-distribute-vertical::before { content: "\f304"; }
+.bi-door-closed-fill::before { content: "\f305"; }
+.bi-door-closed::before { content: "\f306"; }
+.bi-door-open-fill::before { content: "\f307"; }
+.bi-door-open::before { content: "\f308"; }
+.bi-dot::before { content: "\f309"; }
+.bi-download::before { content: "\f30a"; }
+.bi-droplet-fill::before { content: "\f30b"; }
+.bi-droplet-half::before { content: "\f30c"; }
+.bi-droplet::before { content: "\f30d"; }
+.bi-earbuds::before { content: "\f30e"; }
+.bi-easel-fill::before { content: "\f30f"; }
+.bi-easel::before { content: "\f310"; }
+.bi-egg-fill::before { content: "\f311"; }
+.bi-egg-fried::before { content: "\f312"; }
+.bi-egg::before { content: "\f313"; }
+.bi-eject-fill::before { content: "\f314"; }
+.bi-eject::before { content: "\f315"; }
+.bi-emoji-angry-fill::before { content: "\f316"; }
+.bi-emoji-angry::before { content: "\f317"; }
+.bi-emoji-dizzy-fill::before { content: "\f318"; }
+.bi-emoji-dizzy::before { content: "\f319"; }
+.bi-emoji-expressionless-fill::before { content: "\f31a"; }
+.bi-emoji-expressionless::before { content: "\f31b"; }
+.bi-emoji-frown-fill::before { content: "\f31c"; }
+.bi-emoji-frown::before { content: "\f31d"; }
+.bi-emoji-heart-eyes-fill::before { content: "\f31e"; }
+.bi-emoji-heart-eyes::before { content: "\f31f"; }
+.bi-emoji-laughing-fill::before { content: "\f320"; }
+.bi-emoji-laughing::before { content: "\f321"; }
+.bi-emoji-neutral-fill::before { content: "\f322"; }
+.bi-emoji-neutral::before { content: "\f323"; }
+.bi-emoji-smile-fill::before { content: "\f324"; }
+.bi-emoji-smile-upside-down-fill::before { content: "\f325"; }
+.bi-emoji-smile-upside-down::before { content: "\f326"; }
+.bi-emoji-smile::before { content: "\f327"; }
+.bi-emoji-sunglasses-fill::before { content: "\f328"; }
+.bi-emoji-sunglasses::before { content: "\f329"; }
+.bi-emoji-wink-fill::before { content: "\f32a"; }
+.bi-emoji-wink::before { content: "\f32b"; }
+.bi-envelope-fill::before { content: "\f32c"; }
+.bi-envelope-open-fill::before { content: "\f32d"; }
+.bi-envelope-open::before { content: "\f32e"; }
+.bi-envelope::before { content: "\f32f"; }
+.bi-eraser-fill::before { content: "\f330"; }
+.bi-eraser::before { content: "\f331"; }
+.bi-exclamation-circle-fill::before { content: "\f332"; }
+.bi-exclamation-circle::before { content: "\f333"; }
+.bi-exclamation-diamond-fill::before { content: "\f334"; }
+.bi-exclamation-diamond::before { content: "\f335"; }
+.bi-exclamation-octagon-fill::before { content: "\f336"; }
+.bi-exclamation-octagon::before { content: "\f337"; }
+.bi-exclamation-square-fill::before { content: "\f338"; }
+.bi-exclamation-square::before { content: "\f339"; }
+.bi-exclamation-triangle-fill::before { content: "\f33a"; }
+.bi-exclamation-triangle::before { content: "\f33b"; }
+.bi-exclamation::before { content: "\f33c"; }
+.bi-exclude::before { content: "\f33d"; }
+.bi-eye-fill::before { content: "\f33e"; }
+.bi-eye-slash-fill::before { content: "\f33f"; }
+.bi-eye-slash::before { content: "\f340"; }
+.bi-eye::before { content: "\f341"; }
+.bi-eyedropper::before { content: "\f342"; }
+.bi-eyeglasses::before { content: "\f343"; }
+.bi-facebook::before { content: "\f344"; }
+.bi-file-arrow-down-fill::before { content: "\f345"; }
+.bi-file-arrow-down::before { content: "\f346"; }
+.bi-file-arrow-up-fill::before { content: "\f347"; }
+.bi-file-arrow-up::before { content: "\f348"; }
+.bi-file-bar-graph-fill::before { content: "\f349"; }
+.bi-file-bar-graph::before { content: "\f34a"; }
+.bi-file-binary-fill::before { content: "\f34b"; }
+.bi-file-binary::before { content: "\f34c"; }
+.bi-file-break-fill::before { content: "\f34d"; }
+.bi-file-break::before { content: "\f34e"; }
+.bi-file-check-fill::before { content: "\f34f"; }
+.bi-file-check::before { content: "\f350"; }
+.bi-file-code-fill::before { content: "\f351"; }
+.bi-file-code::before { content: "\f352"; }
+.bi-file-diff-fill::before { content: "\f353"; }
+.bi-file-diff::before { content: "\f354"; }
+.bi-file-earmark-arrow-down-fill::before { content: "\f355"; }
+.bi-file-earmark-arrow-down::before { content: "\f356"; }
+.bi-file-earmark-arrow-up-fill::before { content: "\f357"; }
+.bi-file-earmark-arrow-up::before { content: "\f358"; }
+.bi-file-earmark-bar-graph-fill::before { content: "\f359"; }
+.bi-file-earmark-bar-graph::before { content: "\f35a"; }
+.bi-file-earmark-binary-fill::before { content: "\f35b"; }
+.bi-file-earmark-binary::before { content: "\f35c"; }
+.bi-file-earmark-break-fill::before { content: "\f35d"; }
+.bi-file-earmark-break::before { content: "\f35e"; }
+.bi-file-earmark-check-fill::before { content: "\f35f"; }
+.bi-file-earmark-check::before { content: "\f360"; }
+.bi-file-earmark-code-fill::before { content: "\f361"; }
+.bi-file-earmark-code::before { content: "\f362"; }
+.bi-file-earmark-diff-fill::before { content: "\f363"; }
+.bi-file-earmark-diff::before { content: "\f364"; }
+.bi-file-earmark-easel-fill::before { content: "\f365"; }
+.bi-file-earmark-easel::before { content: "\f366"; }
+.bi-file-earmark-excel-fill::before { content: "\f367"; }
+.bi-file-earmark-excel::before { content: "\f368"; }
+.bi-file-earmark-fill::before { content: "\f369"; }
+.bi-file-earmark-font-fill::before { content: "\f36a"; }
+.bi-file-earmark-font::before { content: "\f36b"; }
+.bi-file-earmark-image-fill::before { content: "\f36c"; }
+.bi-file-earmark-image::before { content: "\f36d"; }
+.bi-file-earmark-lock-fill::before { content: "\f36e"; }
+.bi-file-earmark-lock::before { content: "\f36f"; }
+.bi-file-earmark-lock2-fill::before { content: "\f370"; }
+.bi-file-earmark-lock2::before { content: "\f371"; }
+.bi-file-earmark-medical-fill::before { content: "\f372"; }
+.bi-file-earmark-medical::before { content: "\f373"; }
+.bi-file-earmark-minus-fill::before { content: "\f374"; }
+.bi-file-earmark-minus::before { content: "\f375"; }
+.bi-file-earmark-music-fill::before { content: "\f376"; }
+.bi-file-earmark-music::before { content: "\f377"; }
+.bi-file-earmark-person-fill::before { content: "\f378"; }
+.bi-file-earmark-person::before { content: "\f379"; }
+.bi-file-earmark-play-fill::before { content: "\f37a"; }
+.bi-file-earmark-play::before { content: "\f37b"; }
+.bi-file-earmark-plus-fill::before { content: "\f37c"; }
+.bi-file-earmark-plus::before { content: "\f37d"; }
+.bi-file-earmark-post-fill::before { content: "\f37e"; }
+.bi-file-earmark-post::before { content: "\f37f"; }
+.bi-file-earmark-ppt-fill::before { content: "\f380"; }
+.bi-file-earmark-ppt::before { content: "\f381"; }
+.bi-file-earmark-richtext-fill::before { content: "\f382"; }
+.bi-file-earmark-richtext::before { content: "\f383"; }
+.bi-file-earmark-ruled-fill::before { content: "\f384"; }
+.bi-file-earmark-ruled::before { content: "\f385"; }
+.bi-file-earmark-slides-fill::before { content: "\f386"; }
+.bi-file-earmark-slides::before { content: "\f387"; }
+.bi-file-earmark-spreadsheet-fill::before { content: "\f388"; }
+.bi-file-earmark-spreadsheet::before { content: "\f389"; }
+.bi-file-earmark-text-fill::before { content: "\f38a"; }
+.bi-file-earmark-text::before { content: "\f38b"; }
+.bi-file-earmark-word-fill::before { content: "\f38c"; }
+.bi-file-earmark-word::before { content: "\f38d"; }
+.bi-file-earmark-x-fill::before { content: "\f38e"; }
+.bi-file-earmark-x::before { content: "\f38f"; }
+.bi-file-earmark-zip-fill::before { content: "\f390"; }
+.bi-file-earmark-zip::before { content: "\f391"; }
+.bi-file-earmark::before { content: "\f392"; }
+.bi-file-easel-fill::before { content: "\f393"; }
+.bi-file-easel::before { content: "\f394"; }
+.bi-file-excel-fill::before { content: "\f395"; }
+.bi-file-excel::before { content: "\f396"; }
+.bi-file-fill::before { content: "\f397"; }
+.bi-file-font-fill::before { content: "\f398"; }
+.bi-file-font::before { content: "\f399"; }
+.bi-file-image-fill::before { content: "\f39a"; }
+.bi-file-image::before { content: "\f39b"; }
+.bi-file-lock-fill::before { content: "\f39c"; }
+.bi-file-lock::before { content: "\f39d"; }
+.bi-file-lock2-fill::before { content: "\f39e"; }
+.bi-file-lock2::before { content: "\f39f"; }
+.bi-file-medical-fill::before { content: "\f3a0"; }
+.bi-file-medical::before { content: "\f3a1"; }
+.bi-file-minus-fill::before { content: "\f3a2"; }
+.bi-file-minus::before { content: "\f3a3"; }
+.bi-file-music-fill::before { content: "\f3a4"; }
+.bi-file-music::before { content: "\f3a5"; }
+.bi-file-person-fill::before { content: "\f3a6"; }
+.bi-file-person::before { content: "\f3a7"; }
+.bi-file-play-fill::before { content: "\f3a8"; }
+.bi-file-play::before { content: "\f3a9"; }
+.bi-file-plus-fill::before { content: "\f3aa"; }
+.bi-file-plus::before { content: "\f3ab"; }
+.bi-file-post-fill::before { content: "\f3ac"; }
+.bi-file-post::before { content: "\f3ad"; }
+.bi-file-ppt-fill::before { content: "\f3ae"; }
+.bi-file-ppt::before { content: "\f3af"; }
+.bi-file-richtext-fill::before { content: "\f3b0"; }
+.bi-file-richtext::before { content: "\f3b1"; }
+.bi-file-ruled-fill::before { content: "\f3b2"; }
+.bi-file-ruled::before { content: "\f3b3"; }
+.bi-file-slides-fill::before { content: "\f3b4"; }
+.bi-file-slides::before { content: "\f3b5"; }
+.bi-file-spreadsheet-fill::before { content: "\f3b6"; }
+.bi-file-spreadsheet::before { content: "\f3b7"; }
+.bi-file-text-fill::before { content: "\f3b8"; }
+.bi-file-text::before { content: "\f3b9"; }
+.bi-file-word-fill::before { content: "\f3ba"; }
+.bi-file-word::before { content: "\f3bb"; }
+.bi-file-x-fill::before { content: "\f3bc"; }
+.bi-file-x::before { content: "\f3bd"; }
+.bi-file-zip-fill::before { content: "\f3be"; }
+.bi-file-zip::before { content: "\f3bf"; }
+.bi-file::before { content: "\f3c0"; }
+.bi-files-alt::before { content: "\f3c1"; }
+.bi-files::before { content: "\f3c2"; }
+.bi-film::before { content: "\f3c3"; }
+.bi-filter-circle-fill::before { content: "\f3c4"; }
+.bi-filter-circle::before { content: "\f3c5"; }
+.bi-filter-left::before { content: "\f3c6"; }
+.bi-filter-right::before { content: "\f3c7"; }
+.bi-filter-square-fill::before { content: "\f3c8"; }
+.bi-filter-square::before { content: "\f3c9"; }
+.bi-filter::before { content: "\f3ca"; }
+.bi-flag-fill::before { content: "\f3cb"; }
+.bi-flag::before { content: "\f3cc"; }
+.bi-flower1::before { content: "\f3cd"; }
+.bi-flower2::before { content: "\f3ce"; }
+.bi-flower3::before { content: "\f3cf"; }
+.bi-folder-check::before { content: "\f3d0"; }
+.bi-folder-fill::before { content: "\f3d1"; }
+.bi-folder-minus::before { content: "\f3d2"; }
+.bi-folder-plus::before { content: "\f3d3"; }
+.bi-folder-symlink-fill::before { content: "\f3d4"; }
+.bi-folder-symlink::before { content: "\f3d5"; }
+.bi-folder-x::before { content: "\f3d6"; }
+.bi-folder::before { content: "\f3d7"; }
+.bi-folder2-open::before { content: "\f3d8"; }
+.bi-folder2::before { content: "\f3d9"; }
+.bi-fonts::before { content: "\f3da"; }
+.bi-forward-fill::before { content: "\f3db"; }
+.bi-forward::before { content: "\f3dc"; }
+.bi-front::before { content: "\f3dd"; }
+.bi-fullscreen-exit::before { content: "\f3de"; }
+.bi-fullscreen::before { content: "\f3df"; }
+.bi-funnel-fill::before { content: "\f3e0"; }
+.bi-funnel::before { content: "\f3e1"; }
+.bi-gear-fill::before { content: "\f3e2"; }
+.bi-gear-wide-connected::before { content: "\f3e3"; }
+.bi-gear-wide::before { content: "\f3e4"; }
+.bi-gear::before { content: "\f3e5"; }
+.bi-gem::before { content: "\f3e6"; }
+.bi-geo-alt-fill::before { content: "\f3e7"; }
+.bi-geo-alt::before { content: "\f3e8"; }
+.bi-geo-fill::before { content: "\f3e9"; }
+.bi-geo::before { content: "\f3ea"; }
+.bi-gift-fill::before { content: "\f3eb"; }
+.bi-gift::before { content: "\f3ec"; }
+.bi-github::before { content: "\f3ed"; }
+.bi-globe::before { content: "\f3ee"; }
+.bi-globe2::before { content: "\f3ef"; }
+.bi-google::before { content: "\f3f0"; }
+.bi-graph-down::before { content: "\f3f1"; }
+.bi-graph-up::before { content: "\f3f2"; }
+.bi-grid-1x2-fill::before { content: "\f3f3"; }
+.bi-grid-1x2::before { content: "\f3f4"; }
+.bi-grid-3x2-gap-fill::before { content: "\f3f5"; }
+.bi-grid-3x2-gap::before { content: "\f3f6"; }
+.bi-grid-3x2::before { content: "\f3f7"; }
+.bi-grid-3x3-gap-fill::before { content: "\f3f8"; }
+.bi-grid-3x3-gap::before { content: "\f3f9"; }
+.bi-grid-3x3::before { content: "\f3fa"; }
+.bi-grid-fill::before { content: "\f3fb"; }
+.bi-grid::before { content: "\f3fc"; }
+.bi-grip-horizontal::before { content: "\f3fd"; }
+.bi-grip-vertical::before { content: "\f3fe"; }
+.bi-hammer::before { content: "\f3ff"; }
+.bi-hand-index-fill::before { content: "\f400"; }
+.bi-hand-index-thumb-fill::before { content: "\f401"; }
+.bi-hand-index-thumb::before { content: "\f402"; }
+.bi-hand-index::before { content: "\f403"; }
+.bi-hand-thumbs-down-fill::before { content: "\f404"; }
+.bi-hand-thumbs-down::before { content: "\f405"; }
+.bi-hand-thumbs-up-fill::before { content: "\f406"; }
+.bi-hand-thumbs-up::before { content: "\f407"; }
+.bi-handbag-fill::before { content: "\f408"; }
+.bi-handbag::before { content: "\f409"; }
+.bi-hash::before { content: "\f40a"; }
+.bi-hdd-fill::before { content: "\f40b"; }
+.bi-hdd-network-fill::before { content: "\f40c"; }
+.bi-hdd-network::before { content: "\f40d"; }
+.bi-hdd-rack-fill::before { content: "\f40e"; }
+.bi-hdd-rack::before { content: "\f40f"; }
+.bi-hdd-stack-fill::before { content: "\f410"; }
+.bi-hdd-stack::before { content: "\f411"; }
+.bi-hdd::before { content: "\f412"; }
+.bi-headphones::before { content: "\f413"; }
+.bi-headset::before { content: "\f414"; }
+.bi-heart-fill::before { content: "\f415"; }
+.bi-heart-half::before { content: "\f416"; }
+.bi-heart::before { content: "\f417"; }
+.bi-heptagon-fill::before { content: "\f418"; }
+.bi-heptagon-half::before { content: "\f419"; }
+.bi-heptagon::before { content: "\f41a"; }
+.bi-hexagon-fill::before { content: "\f41b"; }
+.bi-hexagon-half::before { content: "\f41c"; }
+.bi-hexagon::before { content: "\f41d"; }
+.bi-hourglass-bottom::before { content: "\f41e"; }
+.bi-hourglass-split::before { content: "\f41f"; }
+.bi-hourglass-top::before { content: "\f420"; }
+.bi-hourglass::before { content: "\f421"; }
+.bi-house-door-fill::before { content: "\f422"; }
+.bi-house-door::before { content: "\f423"; }
+.bi-house-fill::before { content: "\f424"; }
+.bi-house::before { content: "\f425"; }
+.bi-hr::before { content: "\f426"; }
+.bi-hurricane::before { content: "\f427"; }
+.bi-image-alt::before { content: "\f428"; }
+.bi-image-fill::before { content: "\f429"; }
+.bi-image::before { content: "\f42a"; }
+.bi-images::before { content: "\f42b"; }
+.bi-inbox-fill::before { content: "\f42c"; }
+.bi-inbox::before { content: "\f42d"; }
+.bi-inboxes-fill::before { content: "\f42e"; }
+.bi-inboxes::before { content: "\f42f"; }
+.bi-info-circle-fill::before { content: "\f430"; }
+.bi-info-circle::before { content: "\f431"; }
+.bi-info-square-fill::before { content: "\f432"; }
+.bi-info-square::before { content: "\f433"; }
+.bi-info::before { content: "\f434"; }
+.bi-input-cursor-text::before { content: "\f435"; }
+.bi-input-cursor::before { content: "\f436"; }
+.bi-instagram::before { content: "\f437"; }
+.bi-intersect::before { content: "\f438"; }
+.bi-journal-album::before { content: "\f439"; }
+.bi-journal-arrow-down::before { content: "\f43a"; }
+.bi-journal-arrow-up::before { content: "\f43b"; }
+.bi-journal-bookmark-fill::before { content: "\f43c"; }
+.bi-journal-bookmark::before { content: "\f43d"; }
+.bi-journal-check::before { content: "\f43e"; }
+.bi-journal-code::before { content: "\f43f"; }
+.bi-journal-medical::before { content: "\f440"; }
+.bi-journal-minus::before { content: "\f441"; }
+.bi-journal-plus::before { content: "\f442"; }
+.bi-journal-richtext::before { content: "\f443"; }
+.bi-journal-text::before { content: "\f444"; }
+.bi-journal-x::before { content: "\f445"; }
+.bi-journal::before { content: "\f446"; }
+.bi-journals::before { content: "\f447"; }
+.bi-joystick::before { content: "\f448"; }
+.bi-justify-left::before { content: "\f449"; }
+.bi-justify-right::before { content: "\f44a"; }
+.bi-justify::before { content: "\f44b"; }
+.bi-kanban-fill::before { content: "\f44c"; }
+.bi-kanban::before { content: "\f44d"; }
+.bi-key-fill::before { content: "\f44e"; }
+.bi-key::before { content: "\f44f"; }
+.bi-keyboard-fill::before { content: "\f450"; }
+.bi-keyboard::before { content: "\f451"; }
+.bi-ladder::before { content: "\f452"; }
+.bi-lamp-fill::before { content: "\f453"; }
+.bi-lamp::before { content: "\f454"; }
+.bi-laptop-fill::before { content: "\f455"; }
+.bi-laptop::before { content: "\f456"; }
+.bi-layer-backward::before { content: "\f457"; }
+.bi-layer-forward::before { content: "\f458"; }
+.bi-layers-fill::before { content: "\f459"; }
+.bi-layers-half::before { content: "\f45a"; }
+.bi-layers::before { content: "\f45b"; }
+.bi-layout-sidebar-inset-reverse::before { content: "\f45c"; }
+.bi-layout-sidebar-inset::before { content: "\f45d"; }
+.bi-layout-sidebar-reverse::before { content: "\f45e"; }
+.bi-layout-sidebar::before { content: "\f45f"; }
+.bi-layout-split::before { content: "\f460"; }
+.bi-layout-text-sidebar-reverse::before { content: "\f461"; }
+.bi-layout-text-sidebar::before { content: "\f462"; }
+.bi-layout-text-window-reverse::before { content: "\f463"; }
+.bi-layout-text-window::before { content: "\f464"; }
+.bi-layout-three-columns::before { content: "\f465"; }
+.bi-layout-wtf::before { content: "\f466"; }
+.bi-life-preserver::before { content: "\f467"; }
+.bi-lightbulb-fill::before { content: "\f468"; }
+.bi-lightbulb-off-fill::before { content: "\f469"; }
+.bi-lightbulb-off::before { content: "\f46a"; }
+.bi-lightbulb::before { content: "\f46b"; }
+.bi-lightning-charge-fill::before { content: "\f46c"; }
+.bi-lightning-charge::before { content: "\f46d"; }
+.bi-lightning-fill::before { content: "\f46e"; }
+.bi-lightning::before { content: "\f46f"; }
+.bi-link-45deg::before { content: "\f470"; }
+.bi-link::before { content: "\f471"; }
+.bi-linkedin::before { content: "\f472"; }
+.bi-list-check::before { content: "\f473"; }
+.bi-list-nested::before { content: "\f474"; }
+.bi-list-ol::before { content: "\f475"; }
+.bi-list-stars::before { content: "\f476"; }
+.bi-list-task::before { content: "\f477"; }
+.bi-list-ul::before { content: "\f478"; }
+.bi-list::before { content: "\f479"; }
+.bi-lock-fill::before { content: "\f47a"; }
+.bi-lock::before { content: "\f47b"; }
+.bi-mailbox::before { content: "\f47c"; }
+.bi-mailbox2::before { content: "\f47d"; }
+.bi-map-fill::before { content: "\f47e"; }
+.bi-map::before { content: "\f47f"; }
+.bi-markdown-fill::before { content: "\f480"; }
+.bi-markdown::before { content: "\f481"; }
+.bi-mask::before { content: "\f482"; }
+.bi-megaphone-fill::before { content: "\f483"; }
+.bi-megaphone::before { content: "\f484"; }
+.bi-menu-app-fill::before { content: "\f485"; }
+.bi-menu-app::before { content: "\f486"; }
+.bi-menu-button-fill::before { content: "\f487"; }
+.bi-menu-button-wide-fill::before { content: "\f488"; }
+.bi-menu-button-wide::before { content: "\f489"; }
+.bi-menu-button::before { content: "\f48a"; }
+.bi-menu-down::before { content: "\f48b"; }
+.bi-menu-up::before { content: "\f48c"; }
+.bi-mic-fill::before { content: "\f48d"; }
+.bi-mic-mute-fill::before { content: "\f48e"; }
+.bi-mic-mute::before { content: "\f48f"; }
+.bi-mic::before { content: "\f490"; }
+.bi-minecart-loaded::before { content: "\f491"; }
+.bi-minecart::before { content: "\f492"; }
+.bi-moisture::before { content: "\f493"; }
+.bi-moon-fill::before { content: "\f494"; }
+.bi-moon-stars-fill::before { content: "\f495"; }
+.bi-moon-stars::before { content: "\f496"; }
+.bi-moon::before { content: "\f497"; }
+.bi-mouse-fill::before { content: "\f498"; }
+.bi-mouse::before { content: "\f499"; }
+.bi-mouse2-fill::before { content: "\f49a"; }
+.bi-mouse2::before { content: "\f49b"; }
+.bi-mouse3-fill::before { content: "\f49c"; }
+.bi-mouse3::before { content: "\f49d"; }
+.bi-music-note-beamed::before { content: "\f49e"; }
+.bi-music-note-list::before { content: "\f49f"; }
+.bi-music-note::before { content: "\f4a0"; }
+.bi-music-player-fill::before { content: "\f4a1"; }
+.bi-music-player::before { content: "\f4a2"; }
+.bi-newspaper::before { content: "\f4a3"; }
+.bi-node-minus-fill::before { content: "\f4a4"; }
+.bi-node-minus::before { content: "\f4a5"; }
+.bi-node-plus-fill::before { content: "\f4a6"; }
+.bi-node-plus::before { content: "\f4a7"; }
+.bi-nut-fill::before { content: "\f4a8"; }
+.bi-nut::before { content: "\f4a9"; }
+.bi-octagon-fill::before { content: "\f4aa"; }
+.bi-octagon-half::before { content: "\f4ab"; }
+.bi-octagon::before { content: "\f4ac"; }
+.bi-option::before { content: "\f4ad"; }
+.bi-outlet::before { content: "\f4ae"; }
+.bi-paint-bucket::before { content: "\f4af"; }
+.bi-palette-fill::before { content: "\f4b0"; }
+.bi-palette::before { content: "\f4b1"; }
+.bi-palette2::before { content: "\f4b2"; }
+.bi-paperclip::before { content: "\f4b3"; }
+.bi-paragraph::before { content: "\f4b4"; }
+.bi-patch-check-fill::before { content: "\f4b5"; }
+.bi-patch-check::before { content: "\f4b6"; }
+.bi-patch-exclamation-fill::before { content: "\f4b7"; }
+.bi-patch-exclamation::before { content: "\f4b8"; }
+.bi-patch-minus-fill::before { content: "\f4b9"; }
+.bi-patch-minus::before { content: "\f4ba"; }
+.bi-patch-plus-fill::before { content: "\f4bb"; }
+.bi-patch-plus::before { content: "\f4bc"; }
+.bi-patch-question-fill::before { content: "\f4bd"; }
+.bi-patch-question::before { content: "\f4be"; }
+.bi-pause-btn-fill::before { content: "\f4bf"; }
+.bi-pause-btn::before { content: "\f4c0"; }
+.bi-pause-circle-fill::before { content: "\f4c1"; }
+.bi-pause-circle::before { content: "\f4c2"; }
+.bi-pause-fill::before { content: "\f4c3"; }
+.bi-pause::before { content: "\f4c4"; }
+.bi-peace-fill::before { content: "\f4c5"; }
+.bi-peace::before { content: "\f4c6"; }
+.bi-pen-fill::before { content: "\f4c7"; }
+.bi-pen::before { content: "\f4c8"; }
+.bi-pencil-fill::before { content: "\f4c9"; }
+.bi-pencil-square::before { content: "\f4ca"; }
+.bi-pencil::before { content: "\f4cb"; }
+.bi-pentagon-fill::before { content: "\f4cc"; }
+.bi-pentagon-half::before { content: "\f4cd"; }
+.bi-pentagon::before { content: "\f4ce"; }
+.bi-people-fill::before { content: "\f4cf"; }
+.bi-people::before { content: "\f4d0"; }
+.bi-percent::before { content: "\f4d1"; }
+.bi-person-badge-fill::before { content: "\f4d2"; }
+.bi-person-badge::before { content: "\f4d3"; }
+.bi-person-bounding-box::before { content: "\f4d4"; }
+.bi-person-check-fill::before { content: "\f4d5"; }
+.bi-person-check::before { content: "\f4d6"; }
+.bi-person-circle::before { content: "\f4d7"; }
+.bi-person-dash-fill::before { content: "\f4d8"; }
+.bi-person-dash::before { content: "\f4d9"; }
+.bi-person-fill::before { content: "\f4da"; }
+.bi-person-lines-fill::before { content: "\f4db"; }
+.bi-person-plus-fill::before { content: "\f4dc"; }
+.bi-person-plus::before { content: "\f4dd"; }
+.bi-person-square::before { content: "\f4de"; }
+.bi-person-x-fill::before { content: "\f4df"; }
+.bi-person-x::before { content: "\f4e0"; }
+.bi-person::before { content: "\f4e1"; }
+.bi-phone-fill::before { content: "\f4e2"; }
+.bi-phone-landscape-fill::before { content: "\f4e3"; }
+.bi-phone-landscape::before { content: "\f4e4"; }
+.bi-phone-vibrate-fill::before { content: "\f4e5"; }
+.bi-phone-vibrate::before { content: "\f4e6"; }
+.bi-phone::before { content: "\f4e7"; }
+.bi-pie-chart-fill::before { content: "\f4e8"; }
+.bi-pie-chart::before { content: "\f4e9"; }
+.bi-pin-angle-fill::before { content: "\f4ea"; }
+.bi-pin-angle::before { content: "\f4eb"; }
+.bi-pin-fill::before { content: "\f4ec"; }
+.bi-pin::before { content: "\f4ed"; }
+.bi-pip-fill::before { content: "\f4ee"; }
+.bi-pip::before { content: "\f4ef"; }
+.bi-play-btn-fill::before { content: "\f4f0"; }
+.bi-play-btn::before { content: "\f4f1"; }
+.bi-play-circle-fill::before { content: "\f4f2"; }
+.bi-play-circle::before { content: "\f4f3"; }
+.bi-play-fill::before { content: "\f4f4"; }
+.bi-play::before { content: "\f4f5"; }
+.bi-plug-fill::before { content: "\f4f6"; }
+.bi-plug::before { content: "\f4f7"; }
+.bi-plus-circle-dotted::before { content: "\f4f8"; }
+.bi-plus-circle-fill::before { content: "\f4f9"; }
+.bi-plus-circle::before { content: "\f4fa"; }
+.bi-plus-square-dotted::before { content: "\f4fb"; }
+.bi-plus-square-fill::before { content: "\f4fc"; }
+.bi-plus-square::before { content: "\f4fd"; }
+.bi-plus::before { content: "\f4fe"; }
+.bi-power::before { content: "\f4ff"; }
+.bi-printer-fill::before { content: "\f500"; }
+.bi-printer::before { content: "\f501"; }
+.bi-puzzle-fill::before { content: "\f502"; }
+.bi-puzzle::before { content: "\f503"; }
+.bi-question-circle-fill::before { content: "\f504"; }
+.bi-question-circle::before { content: "\f505"; }
+.bi-question-diamond-fill::before { content: "\f506"; }
+.bi-question-diamond::before { content: "\f507"; }
+.bi-question-octagon-fill::before { content: "\f508"; }
+.bi-question-octagon::before { content: "\f509"; }
+.bi-question-square-fill::before { content: "\f50a"; }
+.bi-question-square::before { content: "\f50b"; }
+.bi-question::before { content: "\f50c"; }
+.bi-rainbow::before { content: "\f50d"; }
+.bi-receipt-cutoff::before { content: "\f50e"; }
+.bi-receipt::before { content: "\f50f"; }
+.bi-reception-0::before { content: "\f510"; }
+.bi-reception-1::before { content: "\f511"; }
+.bi-reception-2::before { content: "\f512"; }
+.bi-reception-3::before { content: "\f513"; }
+.bi-reception-4::before { content: "\f514"; }
+.bi-record-btn-fill::before { content: "\f515"; }
+.bi-record-btn::before { content: "\f516"; }
+.bi-record-circle-fill::before { content: "\f517"; }
+.bi-record-circle::before { content: "\f518"; }
+.bi-record-fill::before { content: "\f519"; }
+.bi-record::before { content: "\f51a"; }
+.bi-record2-fill::before { content: "\f51b"; }
+.bi-record2::before { content: "\f51c"; }
+.bi-reply-all-fill::before { content: "\f51d"; }
+.bi-reply-all::before { content: "\f51e"; }
+.bi-reply-fill::before { content: "\f51f"; }
+.bi-reply::before { content: "\f520"; }
+.bi-rss-fill::before { content: "\f521"; }
+.bi-rss::before { content: "\f522"; }
+.bi-rulers::before { content: "\f523"; }
+.bi-save-fill::before { content: "\f524"; }
+.bi-save::before { content: "\f525"; }
+.bi-save2-fill::before { content: "\f526"; }
+.bi-save2::before { content: "\f527"; }
+.bi-scissors::before { content: "\f528"; }
+.bi-screwdriver::before { content: "\f529"; }
+.bi-search::before { content: "\f52a"; }
+.bi-segmented-nav::before { content: "\f52b"; }
+.bi-server::before { content: "\f52c"; }
+.bi-share-fill::before { content: "\f52d"; }
+.bi-share::before { content: "\f52e"; }
+.bi-shield-check::before { content: "\f52f"; }
+.bi-shield-exclamation::before { content: "\f530"; }
+.bi-shield-fill-check::before { content: "\f531"; }
+.bi-shield-fill-exclamation::before { content: "\f532"; }
+.bi-shield-fill-minus::before { content: "\f533"; }
+.bi-shield-fill-plus::before { content: "\f534"; }
+.bi-shield-fill-x::before { content: "\f535"; }
+.bi-shield-fill::before { content: "\f536"; }
+.bi-shield-lock-fill::before { content: "\f537"; }
+.bi-shield-lock::before { content: "\f538"; }
+.bi-shield-minus::before { content: "\f539"; }
+.bi-shield-plus::before { content: "\f53a"; }
+.bi-shield-shaded::before { content: "\f53b"; }
+.bi-shield-slash-fill::before { content: "\f53c"; }
+.bi-shield-slash::before { content: "\f53d"; }
+.bi-shield-x::before { content: "\f53e"; }
+.bi-shield::before { content: "\f53f"; }
+.bi-shift-fill::before { content: "\f540"; }
+.bi-shift::before { content: "\f541"; }
+.bi-shop-window::before { content: "\f542"; }
+.bi-shop::before { content: "\f543"; }
+.bi-shuffle::before { content: "\f544"; }
+.bi-signpost-2-fill::before { content: "\f545"; }
+.bi-signpost-2::before { content: "\f546"; }
+.bi-signpost-fill::before { content: "\f547"; }
+.bi-signpost-split-fill::before { content: "\f548"; }
+.bi-signpost-split::before { content: "\f549"; }
+.bi-signpost::before { content: "\f54a"; }
+.bi-sim-fill::before { content: "\f54b"; }
+.bi-sim::before { content: "\f54c"; }
+.bi-skip-backward-btn-fill::before { content: "\f54d"; }
+.bi-skip-backward-btn::before { content: "\f54e"; }
+.bi-skip-backward-circle-fill::before { content: "\f54f"; }
+.bi-skip-backward-circle::before { content: "\f550"; }
+.bi-skip-backward-fill::before { content: "\f551"; }
+.bi-skip-backward::before { content: "\f552"; }
+.bi-skip-end-btn-fill::before { content: "\f553"; }
+.bi-skip-end-btn::before { content: "\f554"; }
+.bi-skip-end-circle-fill::before { content: "\f555"; }
+.bi-skip-end-circle::before { content: "\f556"; }
+.bi-skip-end-fill::before { content: "\f557"; }
+.bi-skip-end::before { content: "\f558"; }
+.bi-skip-forward-btn-fill::before { content: "\f559"; }
+.bi-skip-forward-btn::before { content: "\f55a"; }
+.bi-skip-forward-circle-fill::before { content: "\f55b"; }
+.bi-skip-forward-circle::before { content: "\f55c"; }
+.bi-skip-forward-fill::before { content: "\f55d"; }
+.bi-skip-forward::before { content: "\f55e"; }
+.bi-skip-start-btn-fill::before { content: "\f55f"; }
+.bi-skip-start-btn::before { content: "\f560"; }
+.bi-skip-start-circle-fill::before { content: "\f561"; }
+.bi-skip-start-circle::before { content: "\f562"; }
+.bi-skip-start-fill::before { content: "\f563"; }
+.bi-skip-start::before { content: "\f564"; }
+.bi-slack::before { content: "\f565"; }
+.bi-slash-circle-fill::before { content: "\f566"; }
+.bi-slash-circle::before { content: "\f567"; }
+.bi-slash-square-fill::before { content: "\f568"; }
+.bi-slash-square::before { content: "\f569"; }
+.bi-slash::before { content: "\f56a"; }
+.bi-sliders::before { content: "\f56b"; }
+.bi-smartwatch::before { content: "\f56c"; }
+.bi-snow::before { content: "\f56d"; }
+.bi-snow2::before { content: "\f56e"; }
+.bi-snow3::before { content: "\f56f"; }
+.bi-sort-alpha-down-alt::before { content: "\f570"; }
+.bi-sort-alpha-down::before { content: "\f571"; }
+.bi-sort-alpha-up-alt::before { content: "\f572"; }
+.bi-sort-alpha-up::before { content: "\f573"; }
+.bi-sort-down-alt::before { content: "\f574"; }
+.bi-sort-down::before { content: "\f575"; }
+.bi-sort-numeric-down-alt::before { content: "\f576"; }
+.bi-sort-numeric-down::before { content: "\f577"; }
+.bi-sort-numeric-up-alt::before { content: "\f578"; }
+.bi-sort-numeric-up::before { content: "\f579"; }
+.bi-sort-up-alt::before { content: "\f57a"; }
+.bi-sort-up::before { content: "\f57b"; }
+.bi-soundwave::before { content: "\f57c"; }
+.bi-speaker-fill::before { content: "\f57d"; }
+.bi-speaker::before { content: "\f57e"; }
+.bi-speedometer::before { content: "\f57f"; }
+.bi-speedometer2::before { content: "\f580"; }
+.bi-spellcheck::before { content: "\f581"; }
+.bi-square-fill::before { content: "\f582"; }
+.bi-square-half::before { content: "\f583"; }
+.bi-square::before { content: "\f584"; }
+.bi-stack::before { content: "\f585"; }
+.bi-star-fill::before { content: "\f586"; }
+.bi-star-half::before { content: "\f587"; }
+.bi-star::before { content: "\f588"; }
+.bi-stars::before { content: "\f589"; }
+.bi-stickies-fill::before { content: "\f58a"; }
+.bi-stickies::before { content: "\f58b"; }
+.bi-sticky-fill::before { content: "\f58c"; }
+.bi-sticky::before { content: "\f58d"; }
+.bi-stop-btn-fill::before { content: "\f58e"; }
+.bi-stop-btn::before { content: "\f58f"; }
+.bi-stop-circle-fill::before { content: "\f590"; }
+.bi-stop-circle::before { content: "\f591"; }
+.bi-stop-fill::before { content: "\f592"; }
+.bi-stop::before { content: "\f593"; }
+.bi-stoplights-fill::before { content: "\f594"; }
+.bi-stoplights::before { content: "\f595"; }
+.bi-stopwatch-fill::before { content: "\f596"; }
+.bi-stopwatch::before { content: "\f597"; }
+.bi-subtract::before { content: "\f598"; }
+.bi-suit-club-fill::before { content: "\f599"; }
+.bi-suit-club::before { content: "\f59a"; }
+.bi-suit-diamond-fill::before { content: "\f59b"; }
+.bi-suit-diamond::before { content: "\f59c"; }
+.bi-suit-heart-fill::before { content: "\f59d"; }
+.bi-suit-heart::before { content: "\f59e"; }
+.bi-suit-spade-fill::before { content: "\f59f"; }
+.bi-suit-spade::before { content: "\f5a0"; }
+.bi-sun-fill::before { content: "\f5a1"; }
+.bi-sun::before { content: "\f5a2"; }
+.bi-sunglasses::before { content: "\f5a3"; }
+.bi-sunrise-fill::before { content: "\f5a4"; }
+.bi-sunrise::before { content: "\f5a5"; }
+.bi-sunset-fill::before { content: "\f5a6"; }
+.bi-sunset::before { content: "\f5a7"; }
+.bi-symmetry-horizontal::before { content: "\f5a8"; }
+.bi-symmetry-vertical::before { content: "\f5a9"; }
+.bi-table::before { content: "\f5aa"; }
+.bi-tablet-fill::before { content: "\f5ab"; }
+.bi-tablet-landscape-fill::before { content: "\f5ac"; }
+.bi-tablet-landscape::before { content: "\f5ad"; }
+.bi-tablet::before { content: "\f5ae"; }
+.bi-tag-fill::before { content: "\f5af"; }
+.bi-tag::before { content: "\f5b0"; }
+.bi-tags-fill::before { content: "\f5b1"; }
+.bi-tags::before { content: "\f5b2"; }
+.bi-telegram::before { content: "\f5b3"; }
+.bi-telephone-fill::before { content: "\f5b4"; }
+.bi-telephone-forward-fill::before { content: "\f5b5"; }
+.bi-telephone-forward::before { content: "\f5b6"; }
+.bi-telephone-inbound-fill::before { content: "\f5b7"; }
+.bi-telephone-inbound::before { content: "\f5b8"; }
+.bi-telephone-minus-fill::before { content: "\f5b9"; }
+.bi-telephone-minus::before { content: "\f5ba"; }
+.bi-telephone-outbound-fill::before { content: "\f5bb"; }
+.bi-telephone-outbound::before { content: "\f5bc"; }
+.bi-telephone-plus-fill::before { content: "\f5bd"; }
+.bi-telephone-plus::before { content: "\f5be"; }
+.bi-telephone-x-fill::before { content: "\f5bf"; }
+.bi-telephone-x::before { content: "\f5c0"; }
+.bi-telephone::before { content: "\f5c1"; }
+.bi-terminal-fill::before { content: "\f5c2"; }
+.bi-terminal::before { content: "\f5c3"; }
+.bi-text-center::before { content: "\f5c4"; }
+.bi-text-indent-left::before { content: "\f5c5"; }
+.bi-text-indent-right::before { content: "\f5c6"; }
+.bi-text-left::before { content: "\f5c7"; }
+.bi-text-paragraph::before { content: "\f5c8"; }
+.bi-text-right::before { content: "\f5c9"; }
+.bi-textarea-resize::before { content: "\f5ca"; }
+.bi-textarea-t::before { content: "\f5cb"; }
+.bi-textarea::before { content: "\f5cc"; }
+.bi-thermometer-half::before { content: "\f5cd"; }
+.bi-thermometer-high::before { content: "\f5ce"; }
+.bi-thermometer-low::before { content: "\f5cf"; }
+.bi-thermometer-snow::before { content: "\f5d0"; }
+.bi-thermometer-sun::before { content: "\f5d1"; }
+.bi-thermometer::before { content: "\f5d2"; }
+.bi-three-dots-vertical::before { content: "\f5d3"; }
+.bi-three-dots::before { content: "\f5d4"; }
+.bi-toggle-off::before { content: "\f5d5"; }
+.bi-toggle-on::before { content: "\f5d6"; }
+.bi-toggle2-off::before { content: "\f5d7"; }
+.bi-toggle2-on::before { content: "\f5d8"; }
+.bi-toggles::before { content: "\f5d9"; }
+.bi-toggles2::before { content: "\f5da"; }
+.bi-tools::before { content: "\f5db"; }
+.bi-tornado::before { content: "\f5dc"; }
+.bi-trash-fill::before { content: "\f5dd"; }
+.bi-trash::before { content: "\f5de"; }
+.bi-trash2-fill::before { content: "\f5df"; }
+.bi-trash2::before { content: "\f5e0"; }
+.bi-tree-fill::before { content: "\f5e1"; }
+.bi-tree::before { content: "\f5e2"; }
+.bi-triangle-fill::before { content: "\f5e3"; }
+.bi-triangle-half::before { content: "\f5e4"; }
+.bi-triangle::before { content: "\f5e5"; }
+.bi-trophy-fill::before { content: "\f5e6"; }
+.bi-trophy::before { content: "\f5e7"; }
+.bi-tropical-storm::before { content: "\f5e8"; }
+.bi-truck-flatbed::before { content: "\f5e9"; }
+.bi-truck::before { content: "\f5ea"; }
+.bi-tsunami::before { content: "\f5eb"; }
+.bi-tv-fill::before { content: "\f5ec"; }
+.bi-tv::before { content: "\f5ed"; }
+.bi-twitch::before { content: "\f5ee"; }
+.bi-twitter::before { content: "\f5ef"; }
+.bi-type-bold::before { content: "\f5f0"; }
+.bi-type-h1::before { content: "\f5f1"; }
+.bi-type-h2::before { content: "\f5f2"; }
+.bi-type-h3::before { content: "\f5f3"; }
+.bi-type-italic::before { content: "\f5f4"; }
+.bi-type-strikethrough::before { content: "\f5f5"; }
+.bi-type-underline::before { content: "\f5f6"; }
+.bi-type::before { content: "\f5f7"; }
+.bi-ui-checks-grid::before { content: "\f5f8"; }
+.bi-ui-checks::before { content: "\f5f9"; }
+.bi-ui-radios-grid::before { content: "\f5fa"; }
+.bi-ui-radios::before { content: "\f5fb"; }
+.bi-umbrella-fill::before { content: "\f5fc"; }
+.bi-umbrella::before { content: "\f5fd"; }
+.bi-union::before { content: "\f5fe"; }
+.bi-unlock-fill::before { content: "\f5ff"; }
+.bi-unlock::before { content: "\f600"; }
+.bi-upc-scan::before { content: "\f601"; }
+.bi-upc::before { content: "\f602"; }
+.bi-upload::before { content: "\f603"; }
+.bi-vector-pen::before { content: "\f604"; }
+.bi-view-list::before { content: "\f605"; }
+.bi-view-stacked::before { content: "\f606"; }
+.bi-vinyl-fill::before { content: "\f607"; }
+.bi-vinyl::before { content: "\f608"; }
+.bi-voicemail::before { content: "\f609"; }
+.bi-volume-down-fill::before { content: "\f60a"; }
+.bi-volume-down::before { content: "\f60b"; }
+.bi-volume-mute-fill::before { content: "\f60c"; }
+.bi-volume-mute::before { content: "\f60d"; }
+.bi-volume-off-fill::before { content: "\f60e"; }
+.bi-volume-off::before { content: "\f60f"; }
+.bi-volume-up-fill::before { content: "\f610"; }
+.bi-volume-up::before { content: "\f611"; }
+.bi-vr::before { content: "\f612"; }
+.bi-wallet-fill::before { content: "\f613"; }
+.bi-wallet::before { content: "\f614"; }
+.bi-wallet2::before { content: "\f615"; }
+.bi-watch::before { content: "\f616"; }
+.bi-water::before { content: "\f617"; }
+.bi-whatsapp::before { content: "\f618"; }
+.bi-wifi-1::before { content: "\f619"; }
+.bi-wifi-2::before { content: "\f61a"; }
+.bi-wifi-off::before { content: "\f61b"; }
+.bi-wifi::before { content: "\f61c"; }
+.bi-wind::before { content: "\f61d"; }
+.bi-window-dock::before { content: "\f61e"; }
+.bi-window-sidebar::before { content: "\f61f"; }
+.bi-window::before { content: "\f620"; }
+.bi-wrench::before { content: "\f621"; }
+.bi-x-circle-fill::before { content: "\f622"; }
+.bi-x-circle::before { content: "\f623"; }
+.bi-x-diamond-fill::before { content: "\f624"; }
+.bi-x-diamond::before { content: "\f625"; }
+.bi-x-octagon-fill::before { content: "\f626"; }
+.bi-x-octagon::before { content: "\f627"; }
+.bi-x-square-fill::before { content: "\f628"; }
+.bi-x-square::before { content: "\f629"; }
+.bi-x::before { content: "\f62a"; }
+.bi-youtube::before { content: "\f62b"; }
+.bi-zoom-in::before { content: "\f62c"; }
+.bi-zoom-out::before { content: "\f62d"; }
+.bi-bank::before { content: "\f62e"; }
+.bi-bank2::before { content: "\f62f"; }
+.bi-bell-slash-fill::before { content: "\f630"; }
+.bi-bell-slash::before { content: "\f631"; }
+.bi-cash-coin::before { content: "\f632"; }
+.bi-check-lg::before { content: "\f633"; }
+.bi-coin::before { content: "\f634"; }
+.bi-currency-bitcoin::before { content: "\f635"; }
+.bi-currency-dollar::before { content: "\f636"; }
+.bi-currency-euro::before { content: "\f637"; }
+.bi-currency-exchange::before { content: "\f638"; }
+.bi-currency-pound::before { content: "\f639"; }
+.bi-currency-yen::before { content: "\f63a"; }
+.bi-dash-lg::before { content: "\f63b"; }
+.bi-exclamation-lg::before { content: "\f63c"; }
+.bi-file-earmark-pdf-fill::before { content: "\f63d"; }
+.bi-file-earmark-pdf::before { content: "\f63e"; }
+.bi-file-pdf-fill::before { content: "\f63f"; }
+.bi-file-pdf::before { content: "\f640"; }
+.bi-gender-ambiguous::before { content: "\f641"; }
+.bi-gender-female::before { content: "\f642"; }
+.bi-gender-male::before { content: "\f643"; }
+.bi-gender-trans::before { content: "\f644"; }
+.bi-headset-vr::before { content: "\f645"; }
+.bi-info-lg::before { content: "\f646"; }
+.bi-mastodon::before { content: "\f647"; }
+.bi-messenger::before { content: "\f648"; }
+.bi-piggy-bank-fill::before { content: "\f649"; }
+.bi-piggy-bank::before { content: "\f64a"; }
+.bi-pin-map-fill::before { content: "\f64b"; }
+.bi-pin-map::before { content: "\f64c"; }
+.bi-plus-lg::before { content: "\f64d"; }
+.bi-question-lg::before { content: "\f64e"; }
+.bi-recycle::before { content: "\f64f"; }
+.bi-reddit::before { content: "\f650"; }
+.bi-safe-fill::before { content: "\f651"; }
+.bi-safe2-fill::before { content: "\f652"; }
+.bi-safe2::before { content: "\f653"; }
+.bi-sd-card-fill::before { content: "\f654"; }
+.bi-sd-card::before { content: "\f655"; }
+.bi-skype::before { content: "\f656"; }
+.bi-slash-lg::before { content: "\f657"; }
+.bi-translate::before { content: "\f658"; }
+.bi-x-lg::before { content: "\f659"; }
+.bi-safe::before { content: "\f65a"; }
+.bi-apple::before { content: "\f65b"; }
+.bi-microsoft::before { content: "\f65d"; }
+.bi-windows::before { content: "\f65e"; }
+.bi-behance::before { content: "\f65c"; }
+.bi-dribbble::before { content: "\f65f"; }
+.bi-line::before { content: "\f660"; }
+.bi-medium::before { content: "\f661"; }
+.bi-paypal::before { content: "\f662"; }
+.bi-pinterest::before { content: "\f663"; }
+.bi-signal::before { content: "\f664"; }
+.bi-snapchat::before { content: "\f665"; }
+.bi-spotify::before { content: "\f666"; }
+.bi-stack-overflow::before { content: "\f667"; }
+.bi-strava::before { content: "\f668"; }
+.bi-wordpress::before { content: "\f669"; }
+.bi-vimeo::before { content: "\f66a"; }
+.bi-activity::before { content: "\f66b"; }
+.bi-easel2-fill::before { content: "\f66c"; }
+.bi-easel2::before { content: "\f66d"; }
+.bi-easel3-fill::before { content: "\f66e"; }
+.bi-easel3::before { content: "\f66f"; }
+.bi-fan::before { content: "\f670"; }
+.bi-fingerprint::before { content: "\f671"; }
+.bi-graph-down-arrow::before { content: "\f672"; }
+.bi-graph-up-arrow::before { content: "\f673"; }
+.bi-hypnotize::before { content: "\f674"; }
+.bi-magic::before { content: "\f675"; }
+.bi-person-rolodex::before { content: "\f676"; }
+.bi-person-video::before { content: "\f677"; }
+.bi-person-video2::before { content: "\f678"; }
+.bi-person-video3::before { content: "\f679"; }
+.bi-person-workspace::before { content: "\f67a"; }
+.bi-radioactive::before { content: "\f67b"; }
+.bi-webcam-fill::before { content: "\f67c"; }
+.bi-webcam::before { content: "\f67d"; }
+.bi-yin-yang::before { content: "\f67e"; }
+.bi-bandaid-fill::before { content: "\f680"; }
+.bi-bandaid::before { content: "\f681"; }
+.bi-bluetooth::before { content: "\f682"; }
+.bi-body-text::before { content: "\f683"; }
+.bi-boombox::before { content: "\f684"; }
+.bi-boxes::before { content: "\f685"; }
+.bi-dpad-fill::before { content: "\f686"; }
+.bi-dpad::before { content: "\f687"; }
+.bi-ear-fill::before { content: "\f688"; }
+.bi-ear::before { content: "\f689"; }
+.bi-envelope-check-fill::before { content: "\f68b"; }
+.bi-envelope-check::before { content: "\f68c"; }
+.bi-envelope-dash-fill::before { content: "\f68e"; }
+.bi-envelope-dash::before { content: "\f68f"; }
+.bi-envelope-exclamation-fill::before { content: "\f691"; }
+.bi-envelope-exclamation::before { content: "\f692"; }
+.bi-envelope-plus-fill::before { content: "\f693"; }
+.bi-envelope-plus::before { content: "\f694"; }
+.bi-envelope-slash-fill::before { content: "\f696"; }
+.bi-envelope-slash::before { content: "\f697"; }
+.bi-envelope-x-fill::before { content: "\f699"; }
+.bi-envelope-x::before { content: "\f69a"; }
+.bi-explicit-fill::before { content: "\f69b"; }
+.bi-explicit::before { content: "\f69c"; }
+.bi-git::before { content: "\f69d"; }
+.bi-infinity::before { content: "\f69e"; }
+.bi-list-columns-reverse::before { content: "\f69f"; }
+.bi-list-columns::before { content: "\f6a0"; }
+.bi-meta::before { content: "\f6a1"; }
+.bi-nintendo-switch::before { content: "\f6a4"; }
+.bi-pc-display-horizontal::before { content: "\f6a5"; }
+.bi-pc-display::before { content: "\f6a6"; }
+.bi-pc-horizontal::before { content: "\f6a7"; }
+.bi-pc::before { content: "\f6a8"; }
+.bi-playstation::before { content: "\f6a9"; }
+.bi-plus-slash-minus::before { content: "\f6aa"; }
+.bi-projector-fill::before { content: "\f6ab"; }
+.bi-projector::before { content: "\f6ac"; }
+.bi-qr-code-scan::before { content: "\f6ad"; }
+.bi-qr-code::before { content: "\f6ae"; }
+.bi-quora::before { content: "\f6af"; }
+.bi-quote::before { content: "\f6b0"; }
+.bi-robot::before { content: "\f6b1"; }
+.bi-send-check-fill::before { content: "\f6b2"; }
+.bi-send-check::before { content: "\f6b3"; }
+.bi-send-dash-fill::before { content: "\f6b4"; }
+.bi-send-dash::before { content: "\f6b5"; }
+.bi-send-exclamation-fill::before { content: "\f6b7"; }
+.bi-send-exclamation::before { content: "\f6b8"; }
+.bi-send-fill::before { content: "\f6b9"; }
+.bi-send-plus-fill::before { content: "\f6ba"; }
+.bi-send-plus::before { content: "\f6bb"; }
+.bi-send-slash-fill::before { content: "\f6bc"; }
+.bi-send-slash::before { content: "\f6bd"; }
+.bi-send-x-fill::before { content: "\f6be"; }
+.bi-send-x::before { content: "\f6bf"; }
+.bi-send::before { content: "\f6c0"; }
+.bi-steam::before { content: "\f6c1"; }
+.bi-terminal-dash::before { content: "\f6c3"; }
+.bi-terminal-plus::before { content: "\f6c4"; }
+.bi-terminal-split::before { content: "\f6c5"; }
+.bi-ticket-detailed-fill::before { content: "\f6c6"; }
+.bi-ticket-detailed::before { content: "\f6c7"; }
+.bi-ticket-fill::before { content: "\f6c8"; }
+.bi-ticket-perforated-fill::before { content: "\f6c9"; }
+.bi-ticket-perforated::before { content: "\f6ca"; }
+.bi-ticket::before { content: "\f6cb"; }
+.bi-tiktok::before { content: "\f6cc"; }
+.bi-window-dash::before { content: "\f6cd"; }
+.bi-window-desktop::before { content: "\f6ce"; }
+.bi-window-fullscreen::before { content: "\f6cf"; }
+.bi-window-plus::before { content: "\f6d0"; }
+.bi-window-split::before { content: "\f6d1"; }
+.bi-window-stack::before { content: "\f6d2"; }
+.bi-window-x::before { content: "\f6d3"; }
+.bi-xbox::before { content: "\f6d4"; }
+.bi-ethernet::before { content: "\f6d5"; }
+.bi-hdmi-fill::before { content: "\f6d6"; }
+.bi-hdmi::before { content: "\f6d7"; }
+.bi-usb-c-fill::before { content: "\f6d8"; }
+.bi-usb-c::before { content: "\f6d9"; }
+.bi-usb-fill::before { content: "\f6da"; }
+.bi-usb-plug-fill::before { content: "\f6db"; }
+.bi-usb-plug::before { content: "\f6dc"; }
+.bi-usb-symbol::before { content: "\f6dd"; }
+.bi-usb::before { content: "\f6de"; }
+.bi-boombox-fill::before { content: "\f6df"; }
+.bi-displayport::before { content: "\f6e1"; }
+.bi-gpu-card::before { content: "\f6e2"; }
+.bi-memory::before { content: "\f6e3"; }
+.bi-modem-fill::before { content: "\f6e4"; }
+.bi-modem::before { content: "\f6e5"; }
+.bi-motherboard-fill::before { content: "\f6e6"; }
+.bi-motherboard::before { content: "\f6e7"; }
+.bi-optical-audio-fill::before { content: "\f6e8"; }
+.bi-optical-audio::before { content: "\f6e9"; }
+.bi-pci-card::before { content: "\f6ea"; }
+.bi-router-fill::before { content: "\f6eb"; }
+.bi-router::before { content: "\f6ec"; }
+.bi-thunderbolt-fill::before { content: "\f6ef"; }
+.bi-thunderbolt::before { content: "\f6f0"; }
+.bi-usb-drive-fill::before { content: "\f6f1"; }
+.bi-usb-drive::before { content: "\f6f2"; }
+.bi-usb-micro-fill::before { content: "\f6f3"; }
+.bi-usb-micro::before { content: "\f6f4"; }
+.bi-usb-mini-fill::before { content: "\f6f5"; }
+.bi-usb-mini::before { content: "\f6f6"; }
+.bi-cloud-haze2::before { content: "\f6f7"; }
+.bi-device-hdd-fill::before { content: "\f6f8"; }
+.bi-device-hdd::before { content: "\f6f9"; }
+.bi-device-ssd-fill::before { content: "\f6fa"; }
+.bi-device-ssd::before { content: "\f6fb"; }
+.bi-displayport-fill::before { content: "\f6fc"; }
+.bi-mortarboard-fill::before { content: "\f6fd"; }
+.bi-mortarboard::before { content: "\f6fe"; }
+.bi-terminal-x::before { content: "\f6ff"; }
+.bi-arrow-through-heart-fill::before { content: "\f700"; }
+.bi-arrow-through-heart::before { content: "\f701"; }
+.bi-badge-sd-fill::before { content: "\f702"; }
+.bi-badge-sd::before { content: "\f703"; }
+.bi-bag-heart-fill::before { content: "\f704"; }
+.bi-bag-heart::before { content: "\f705"; }
+.bi-balloon-fill::before { content: "\f706"; }
+.bi-balloon-heart-fill::before { content: "\f707"; }
+.bi-balloon-heart::before { content: "\f708"; }
+.bi-balloon::before { content: "\f709"; }
+.bi-box2-fill::before { content: "\f70a"; }
+.bi-box2-heart-fill::before { content: "\f70b"; }
+.bi-box2-heart::before { content: "\f70c"; }
+.bi-box2::before { content: "\f70d"; }
+.bi-braces-asterisk::before { content: "\f70e"; }
+.bi-calendar-heart-fill::before { content: "\f70f"; }
+.bi-calendar-heart::before { content: "\f710"; }
+.bi-calendar2-heart-fill::before { content: "\f711"; }
+.bi-calendar2-heart::before { content: "\f712"; }
+.bi-chat-heart-fill::before { content: "\f713"; }
+.bi-chat-heart::before { content: "\f714"; }
+.bi-chat-left-heart-fill::before { content: "\f715"; }
+.bi-chat-left-heart::before { content: "\f716"; }
+.bi-chat-right-heart-fill::before { content: "\f717"; }
+.bi-chat-right-heart::before { content: "\f718"; }
+.bi-chat-square-heart-fill::before { content: "\f719"; }
+.bi-chat-square-heart::before { content: "\f71a"; }
+.bi-clipboard-check-fill::before { content: "\f71b"; }
+.bi-clipboard-data-fill::before { content: "\f71c"; }
+.bi-clipboard-fill::before { content: "\f71d"; }
+.bi-clipboard-heart-fill::before { content: "\f71e"; }
+.bi-clipboard-heart::before { content: "\f71f"; }
+.bi-clipboard-minus-fill::before { content: "\f720"; }
+.bi-clipboard-plus-fill::before { content: "\f721"; }
+.bi-clipboard-pulse::before { content: "\f722"; }
+.bi-clipboard-x-fill::before { content: "\f723"; }
+.bi-clipboard2-check-fill::before { content: "\f724"; }
+.bi-clipboard2-check::before { content: "\f725"; }
+.bi-clipboard2-data-fill::before { content: "\f726"; }
+.bi-clipboard2-data::before { content: "\f727"; }
+.bi-clipboard2-fill::before { content: "\f728"; }
+.bi-clipboard2-heart-fill::before { content: "\f729"; }
+.bi-clipboard2-heart::before { content: "\f72a"; }
+.bi-clipboard2-minus-fill::before { content: "\f72b"; }
+.bi-clipboard2-minus::before { content: "\f72c"; }
+.bi-clipboard2-plus-fill::before { content: "\f72d"; }
+.bi-clipboard2-plus::before { content: "\f72e"; }
+.bi-clipboard2-pulse-fill::before { content: "\f72f"; }
+.bi-clipboard2-pulse::before { content: "\f730"; }
+.bi-clipboard2-x-fill::before { content: "\f731"; }
+.bi-clipboard2-x::before { content: "\f732"; }
+.bi-clipboard2::before { content: "\f733"; }
+.bi-emoji-kiss-fill::before { content: "\f734"; }
+.bi-emoji-kiss::before { content: "\f735"; }
+.bi-envelope-heart-fill::before { content: "\f736"; }
+.bi-envelope-heart::before { content: "\f737"; }
+.bi-envelope-open-heart-fill::before { content: "\f738"; }
+.bi-envelope-open-heart::before { content: "\f739"; }
+.bi-envelope-paper-fill::before { content: "\f73a"; }
+.bi-envelope-paper-heart-fill::before { content: "\f73b"; }
+.bi-envelope-paper-heart::before { content: "\f73c"; }
+.bi-envelope-paper::before { content: "\f73d"; }
+.bi-filetype-aac::before { content: "\f73e"; }
+.bi-filetype-ai::before { content: "\f73f"; }
+.bi-filetype-bmp::before { content: "\f740"; }
+.bi-filetype-cs::before { content: "\f741"; }
+.bi-filetype-css::before { content: "\f742"; }
+.bi-filetype-csv::before { content: "\f743"; }
+.bi-filetype-doc::before { content: "\f744"; }
+.bi-filetype-docx::before { content: "\f745"; }
+.bi-filetype-exe::before { content: "\f746"; }
+.bi-filetype-gif::before { content: "\f747"; }
+.bi-filetype-heic::before { content: "\f748"; }
+.bi-filetype-html::before { content: "\f749"; }
+.bi-filetype-java::before { content: "\f74a"; }
+.bi-filetype-jpg::before { content: "\f74b"; }
+.bi-filetype-js::before { content: "\f74c"; }
+.bi-filetype-jsx::before { content: "\f74d"; }
+.bi-filetype-key::before { content: "\f74e"; }
+.bi-filetype-m4p::before { content: "\f74f"; }
+.bi-filetype-md::before { content: "\f750"; }
+.bi-filetype-mdx::before { content: "\f751"; }
+.bi-filetype-mov::before { content: "\f752"; }
+.bi-filetype-mp3::before { content: "\f753"; }
+.bi-filetype-mp4::before { content: "\f754"; }
+.bi-filetype-otf::before { content: "\f755"; }
+.bi-filetype-pdf::before { content: "\f756"; }
+.bi-filetype-php::before { content: "\f757"; }
+.bi-filetype-png::before { content: "\f758"; }
+.bi-filetype-ppt::before { content: "\f75a"; }
+.bi-filetype-psd::before { content: "\f75b"; }
+.bi-filetype-py::before { content: "\f75c"; }
+.bi-filetype-raw::before { content: "\f75d"; }
+.bi-filetype-rb::before { content: "\f75e"; }
+.bi-filetype-sass::before { content: "\f75f"; }
+.bi-filetype-scss::before { content: "\f760"; }
+.bi-filetype-sh::before { content: "\f761"; }
+.bi-filetype-svg::before { content: "\f762"; }
+.bi-filetype-tiff::before { content: "\f763"; }
+.bi-filetype-tsx::before { content: "\f764"; }
+.bi-filetype-ttf::before { content: "\f765"; }
+.bi-filetype-txt::before { content: "\f766"; }
+.bi-filetype-wav::before { content: "\f767"; }
+.bi-filetype-woff::before { content: "\f768"; }
+.bi-filetype-xls::before { content: "\f76a"; }
+.bi-filetype-xml::before { content: "\f76b"; }
+.bi-filetype-yml::before { content: "\f76c"; }
+.bi-heart-arrow::before { content: "\f76d"; }
+.bi-heart-pulse-fill::before { content: "\f76e"; }
+.bi-heart-pulse::before { content: "\f76f"; }
+.bi-heartbreak-fill::before { content: "\f770"; }
+.bi-heartbreak::before { content: "\f771"; }
+.bi-hearts::before { content: "\f772"; }
+.bi-hospital-fill::before { content: "\f773"; }
+.bi-hospital::before { content: "\f774"; }
+.bi-house-heart-fill::before { content: "\f775"; }
+.bi-house-heart::before { content: "\f776"; }
+.bi-incognito::before { content: "\f777"; }
+.bi-magnet-fill::before { content: "\f778"; }
+.bi-magnet::before { content: "\f779"; }
+.bi-person-heart::before { content: "\f77a"; }
+.bi-person-hearts::before { content: "\f77b"; }
+.bi-phone-flip::before { content: "\f77c"; }
+.bi-plugin::before { content: "\f77d"; }
+.bi-postage-fill::before { content: "\f77e"; }
+.bi-postage-heart-fill::before { content: "\f77f"; }
+.bi-postage-heart::before { content: "\f780"; }
+.bi-postage::before { content: "\f781"; }
+.bi-postcard-fill::before { content: "\f782"; }
+.bi-postcard-heart-fill::before { content: "\f783"; }
+.bi-postcard-heart::before { content: "\f784"; }
+.bi-postcard::before { content: "\f785"; }
+.bi-search-heart-fill::before { content: "\f786"; }
+.bi-search-heart::before { content: "\f787"; }
+.bi-sliders2-vertical::before { content: "\f788"; }
+.bi-sliders2::before { content: "\f789"; }
+.bi-trash3-fill::before { content: "\f78a"; }
+.bi-trash3::before { content: "\f78b"; }
+.bi-valentine::before { content: "\f78c"; }
+.bi-valentine2::before { content: "\f78d"; }
+.bi-wrench-adjustable-circle-fill::before { content: "\f78e"; }
+.bi-wrench-adjustable-circle::before { content: "\f78f"; }
+.bi-wrench-adjustable::before { content: "\f790"; }
+.bi-filetype-json::before { content: "\f791"; }
+.bi-filetype-pptx::before { content: "\f792"; }
+.bi-filetype-xlsx::before { content: "\f793"; }
+.bi-1-circle-fill::before { content: "\f796"; }
+.bi-1-circle::before { content: "\f797"; }
+.bi-1-square-fill::before { content: "\f798"; }
+.bi-1-square::before { content: "\f799"; }
+.bi-2-circle-fill::before { content: "\f79c"; }
+.bi-2-circle::before { content: "\f79d"; }
+.bi-2-square-fill::before { content: "\f79e"; }
+.bi-2-square::before { content: "\f79f"; }
+.bi-3-circle-fill::before { content: "\f7a2"; }
+.bi-3-circle::before { content: "\f7a3"; }
+.bi-3-square-fill::before { content: "\f7a4"; }
+.bi-3-square::before { content: "\f7a5"; }
+.bi-4-circle-fill::before { content: "\f7a8"; }
+.bi-4-circle::before { content: "\f7a9"; }
+.bi-4-square-fill::before { content: "\f7aa"; }
+.bi-4-square::before { content: "\f7ab"; }
+.bi-5-circle-fill::before { content: "\f7ae"; }
+.bi-5-circle::before { content: "\f7af"; }
+.bi-5-square-fill::before { content: "\f7b0"; }
+.bi-5-square::before { content: "\f7b1"; }
+.bi-6-circle-fill::before { content: "\f7b4"; }
+.bi-6-circle::before { content: "\f7b5"; }
+.bi-6-square-fill::before { content: "\f7b6"; }
+.bi-6-square::before { content: "\f7b7"; }
+.bi-7-circle-fill::before { content: "\f7ba"; }
+.bi-7-circle::before { content: "\f7bb"; }
+.bi-7-square-fill::before { content: "\f7bc"; }
+.bi-7-square::before { content: "\f7bd"; }
+.bi-8-circle-fill::before { content: "\f7c0"; }
+.bi-8-circle::before { content: "\f7c1"; }
+.bi-8-square-fill::before { content: "\f7c2"; }
+.bi-8-square::before { content: "\f7c3"; }
+.bi-9-circle-fill::before { content: "\f7c6"; }
+.bi-9-circle::before { content: "\f7c7"; }
+.bi-9-square-fill::before { content: "\f7c8"; }
+.bi-9-square::before { content: "\f7c9"; }
+.bi-airplane-engines-fill::before { content: "\f7ca"; }
+.bi-airplane-engines::before { content: "\f7cb"; }
+.bi-airplane-fill::before { content: "\f7cc"; }
+.bi-airplane::before { content: "\f7cd"; }
+.bi-alexa::before { content: "\f7ce"; }
+.bi-alipay::before { content: "\f7cf"; }
+.bi-android::before { content: "\f7d0"; }
+.bi-android2::before { content: "\f7d1"; }
+.bi-box-fill::before { content: "\f7d2"; }
+.bi-box-seam-fill::before { content: "\f7d3"; }
+.bi-browser-chrome::before { content: "\f7d4"; }
+.bi-browser-edge::before { content: "\f7d5"; }
+.bi-browser-firefox::before { content: "\f7d6"; }
+.bi-browser-safari::before { content: "\f7d7"; }
+.bi-c-circle-fill::before { content: "\f7da"; }
+.bi-c-circle::before { content: "\f7db"; }
+.bi-c-square-fill::before { content: "\f7dc"; }
+.bi-c-square::before { content: "\f7dd"; }
+.bi-capsule-pill::before { content: "\f7de"; }
+.bi-capsule::before { content: "\f7df"; }
+.bi-car-front-fill::before { content: "\f7e0"; }
+.bi-car-front::before { content: "\f7e1"; }
+.bi-cassette-fill::before { content: "\f7e2"; }
+.bi-cassette::before { content: "\f7e3"; }
+.bi-cc-circle-fill::before { content: "\f7e6"; }
+.bi-cc-circle::before { content: "\f7e7"; }
+.bi-cc-square-fill::before { content: "\f7e8"; }
+.bi-cc-square::before { content: "\f7e9"; }
+.bi-cup-hot-fill::before { content: "\f7ea"; }
+.bi-cup-hot::before { content: "\f7eb"; }
+.bi-currency-rupee::before { content: "\f7ec"; }
+.bi-dropbox::before { content: "\f7ed"; }
+.bi-escape::before { content: "\f7ee"; }
+.bi-fast-forward-btn-fill::before { content: "\f7ef"; }
+.bi-fast-forward-btn::before { content: "\f7f0"; }
+.bi-fast-forward-circle-fill::before { content: "\f7f1"; }
+.bi-fast-forward-circle::before { content: "\f7f2"; }
+.bi-fast-forward-fill::before { content: "\f7f3"; }
+.bi-fast-forward::before { content: "\f7f4"; }
+.bi-filetype-sql::before { content: "\f7f5"; }
+.bi-fire::before { content: "\f7f6"; }
+.bi-google-play::before { content: "\f7f7"; }
+.bi-h-circle-fill::before { content: "\f7fa"; }
+.bi-h-circle::before { content: "\f7fb"; }
+.bi-h-square-fill::before { content: "\f7fc"; }
+.bi-h-square::before { content: "\f7fd"; }
+.bi-indent::before { content: "\f7fe"; }
+.bi-lungs-fill::before { content: "\f7ff"; }
+.bi-lungs::before { content: "\f800"; }
+.bi-microsoft-teams::before { content: "\f801"; }
+.bi-p-circle-fill::before { content: "\f804"; }
+.bi-p-circle::before { content: "\f805"; }
+.bi-p-square-fill::before { content: "\f806"; }
+.bi-p-square::before { content: "\f807"; }
+.bi-pass-fill::before { content: "\f808"; }
+.bi-pass::before { content: "\f809"; }
+.bi-prescription::before { content: "\f80a"; }
+.bi-prescription2::before { content: "\f80b"; }
+.bi-r-circle-fill::before { content: "\f80e"; }
+.bi-r-circle::before { content: "\f80f"; }
+.bi-r-square-fill::before { content: "\f810"; }
+.bi-r-square::before { content: "\f811"; }
+.bi-repeat-1::before { content: "\f812"; }
+.bi-repeat::before { content: "\f813"; }
+.bi-rewind-btn-fill::before { content: "\f814"; }
+.bi-rewind-btn::before { content: "\f815"; }
+.bi-rewind-circle-fill::before { content: "\f816"; }
+.bi-rewind-circle::before { content: "\f817"; }
+.bi-rewind-fill::before { content: "\f818"; }
+.bi-rewind::before { content: "\f819"; }
+.bi-train-freight-front-fill::before { content: "\f81a"; }
+.bi-train-freight-front::before { content: "\f81b"; }
+.bi-train-front-fill::before { content: "\f81c"; }
+.bi-train-front::before { content: "\f81d"; }
+.bi-train-lightrail-front-fill::before { content: "\f81e"; }
+.bi-train-lightrail-front::before { content: "\f81f"; }
+.bi-truck-front-fill::before { content: "\f820"; }
+.bi-truck-front::before { content: "\f821"; }
+.bi-ubuntu::before { content: "\f822"; }
+.bi-unindent::before { content: "\f823"; }
+.bi-unity::before { content: "\f824"; }
+.bi-universal-access-circle::before { content: "\f825"; }
+.bi-universal-access::before { content: "\f826"; }
+.bi-virus::before { content: "\f827"; }
+.bi-virus2::before { content: "\f828"; }
+.bi-wechat::before { content: "\f829"; }
+.bi-yelp::before { content: "\f82a"; }
+.bi-sign-stop-fill::before { content: "\f82b"; }
+.bi-sign-stop-lights-fill::before { content: "\f82c"; }
+.bi-sign-stop-lights::before { content: "\f82d"; }
+.bi-sign-stop::before { content: "\f82e"; }
+.bi-sign-turn-left-fill::before { content: "\f82f"; }
+.bi-sign-turn-left::before { content: "\f830"; }
+.bi-sign-turn-right-fill::before { content: "\f831"; }
+.bi-sign-turn-right::before { content: "\f832"; }
+.bi-sign-turn-slight-left-fill::before { content: "\f833"; }
+.bi-sign-turn-slight-left::before { content: "\f834"; }
+.bi-sign-turn-slight-right-fill::before { content: "\f835"; }
+.bi-sign-turn-slight-right::before { content: "\f836"; }
+.bi-sign-yield-fill::before { content: "\f837"; }
+.bi-sign-yield::before { content: "\f838"; }
+.bi-ev-station-fill::before { content: "\f839"; }
+.bi-ev-station::before { content: "\f83a"; }
+.bi-fuel-pump-diesel-fill::before { content: "\f83b"; }
+.bi-fuel-pump-diesel::before { content: "\f83c"; }
+.bi-fuel-pump-fill::before { content: "\f83d"; }
+.bi-fuel-pump::before { content: "\f83e"; }
+.bi-0-circle-fill::before { content: "\f83f"; }
+.bi-0-circle::before { content: "\f840"; }
+.bi-0-square-fill::before { content: "\f841"; }
+.bi-0-square::before { content: "\f842"; }
+.bi-rocket-fill::before { content: "\f843"; }
+.bi-rocket-takeoff-fill::before { content: "\f844"; }
+.bi-rocket-takeoff::before { content: "\f845"; }
+.bi-rocket::before { content: "\f846"; }
+.bi-stripe::before { content: "\f847"; }
+.bi-subscript::before { content: "\f848"; }
+.bi-superscript::before { content: "\f849"; }
+.bi-trello::before { content: "\f84a"; }
+.bi-envelope-at-fill::before { content: "\f84b"; }
+.bi-envelope-at::before { content: "\f84c"; }
+.bi-regex::before { content: "\f84d"; }
+.bi-text-wrap::before { content: "\f84e"; }
+.bi-sign-dead-end-fill::before { content: "\f84f"; }
+.bi-sign-dead-end::before { content: "\f850"; }
+.bi-sign-do-not-enter-fill::before { content: "\f851"; }
+.bi-sign-do-not-enter::before { content: "\f852"; }
+.bi-sign-intersection-fill::before { content: "\f853"; }
+.bi-sign-intersection-side-fill::before { content: "\f854"; }
+.bi-sign-intersection-side::before { content: "\f855"; }
+.bi-sign-intersection-t-fill::before { content: "\f856"; }
+.bi-sign-intersection-t::before { content: "\f857"; }
+.bi-sign-intersection-y-fill::before { content: "\f858"; }
+.bi-sign-intersection-y::before { content: "\f859"; }
+.bi-sign-intersection::before { content: "\f85a"; }
+.bi-sign-merge-left-fill::before { content: "\f85b"; }
+.bi-sign-merge-left::before { content: "\f85c"; }
+.bi-sign-merge-right-fill::before { content: "\f85d"; }
+.bi-sign-merge-right::before { content: "\f85e"; }
+.bi-sign-no-left-turn-fill::before { content: "\f85f"; }
+.bi-sign-no-left-turn::before { content: "\f860"; }
+.bi-sign-no-parking-fill::before { content: "\f861"; }
+.bi-sign-no-parking::before { content: "\f862"; }
+.bi-sign-no-right-turn-fill::before { content: "\f863"; }
+.bi-sign-no-right-turn::before { content: "\f864"; }
+.bi-sign-railroad-fill::before { content: "\f865"; }
+.bi-sign-railroad::before { content: "\f866"; }
+.bi-building-add::before { content: "\f867"; }
+.bi-building-check::before { content: "\f868"; }
+.bi-building-dash::before { content: "\f869"; }
+.bi-building-down::before { content: "\f86a"; }
+.bi-building-exclamation::before { content: "\f86b"; }
+.bi-building-fill-add::before { content: "\f86c"; }
+.bi-building-fill-check::before { content: "\f86d"; }
+.bi-building-fill-dash::before { content: "\f86e"; }
+.bi-building-fill-down::before { content: "\f86f"; }
+.bi-building-fill-exclamation::before { content: "\f870"; }
+.bi-building-fill-gear::before { content: "\f871"; }
+.bi-building-fill-lock::before { content: "\f872"; }
+.bi-building-fill-slash::before { content: "\f873"; }
+.bi-building-fill-up::before { content: "\f874"; }
+.bi-building-fill-x::before { content: "\f875"; }
+.bi-building-fill::before { content: "\f876"; }
+.bi-building-gear::before { content: "\f877"; }
+.bi-building-lock::before { content: "\f878"; }
+.bi-building-slash::before { content: "\f879"; }
+.bi-building-up::before { content: "\f87a"; }
+.bi-building-x::before { content: "\f87b"; }
+.bi-buildings-fill::before { content: "\f87c"; }
+.bi-buildings::before { content: "\f87d"; }
+.bi-bus-front-fill::before { content: "\f87e"; }
+.bi-bus-front::before { content: "\f87f"; }
+.bi-ev-front-fill::before { content: "\f880"; }
+.bi-ev-front::before { content: "\f881"; }
+.bi-globe-americas::before { content: "\f882"; }
+.bi-globe-asia-australia::before { content: "\f883"; }
+.bi-globe-central-south-asia::before { content: "\f884"; }
+.bi-globe-europe-africa::before { content: "\f885"; }
+.bi-house-add-fill::before { content: "\f886"; }
+.bi-house-add::before { content: "\f887"; }
+.bi-house-check-fill::before { content: "\f888"; }
+.bi-house-check::before { content: "\f889"; }
+.bi-house-dash-fill::before { content: "\f88a"; }
+.bi-house-dash::before { content: "\f88b"; }
+.bi-house-down-fill::before { content: "\f88c"; }
+.bi-house-down::before { content: "\f88d"; }
+.bi-house-exclamation-fill::before { content: "\f88e"; }
+.bi-house-exclamation::before { content: "\f88f"; }
+.bi-house-gear-fill::before { content: "\f890"; }
+.bi-house-gear::before { content: "\f891"; }
+.bi-house-lock-fill::before { content: "\f892"; }
+.bi-house-lock::before { content: "\f893"; }
+.bi-house-slash-fill::before { content: "\f894"; }
+.bi-house-slash::before { content: "\f895"; }
+.bi-house-up-fill::before { content: "\f896"; }
+.bi-house-up::before { content: "\f897"; }
+.bi-house-x-fill::before { content: "\f898"; }
+.bi-house-x::before { content: "\f899"; }
+.bi-person-add::before { content: "\f89a"; }
+.bi-person-down::before { content: "\f89b"; }
+.bi-person-exclamation::before { content: "\f89c"; }
+.bi-person-fill-add::before { content: "\f89d"; }
+.bi-person-fill-check::before { content: "\f89e"; }
+.bi-person-fill-dash::before { content: "\f89f"; }
+.bi-person-fill-down::before { content: "\f8a0"; }
+.bi-person-fill-exclamation::before { content: "\f8a1"; }
+.bi-person-fill-gear::before { content: "\f8a2"; }
+.bi-person-fill-lock::before { content: "\f8a3"; }
+.bi-person-fill-slash::before { content: "\f8a4"; }
+.bi-person-fill-up::before { content: "\f8a5"; }
+.bi-person-fill-x::before { content: "\f8a6"; }
+.bi-person-gear::before { content: "\f8a7"; }
+.bi-person-lock::before { content: "\f8a8"; }
+.bi-person-slash::before { content: "\f8a9"; }
+.bi-person-up::before { content: "\f8aa"; }
+.bi-scooter::before { content: "\f8ab"; }
+.bi-taxi-front-fill::before { content: "\f8ac"; }
+.bi-taxi-front::before { content: "\f8ad"; }
+.bi-amd::before { content: "\f8ae"; }
+.bi-database-add::before { content: "\f8af"; }
+.bi-database-check::before { content: "\f8b0"; }
+.bi-database-dash::before { content: "\f8b1"; }
+.bi-database-down::before { content: "\f8b2"; }
+.bi-database-exclamation::before { content: "\f8b3"; }
+.bi-database-fill-add::before { content: "\f8b4"; }
+.bi-database-fill-check::before { content: "\f8b5"; }
+.bi-database-fill-dash::before { content: "\f8b6"; }
+.bi-database-fill-down::before { content: "\f8b7"; }
+.bi-database-fill-exclamation::before { content: "\f8b8"; }
+.bi-database-fill-gear::before { content: "\f8b9"; }
+.bi-database-fill-lock::before { content: "\f8ba"; }
+.bi-database-fill-slash::before { content: "\f8bb"; }
+.bi-database-fill-up::before { content: "\f8bc"; }
+.bi-database-fill-x::before { content: "\f8bd"; }
+.bi-database-fill::before { content: "\f8be"; }
+.bi-database-gear::before { content: "\f8bf"; }
+.bi-database-lock::before { content: "\f8c0"; }
+.bi-database-slash::before { content: "\f8c1"; }
+.bi-database-up::before { content: "\f8c2"; }
+.bi-database-x::before { content: "\f8c3"; }
+.bi-database::before { content: "\f8c4"; }
+.bi-houses-fill::before { content: "\f8c5"; }
+.bi-houses::before { content: "\f8c6"; }
+.bi-nvidia::before { content: "\f8c7"; }
+.bi-person-vcard-fill::before { content: "\f8c8"; }
+.bi-person-vcard::before { content: "\f8c9"; }
+.bi-sina-weibo::before { content: "\f8ca"; }
+.bi-tencent-qq::before { content: "\f8cb"; }
+.bi-wikipedia::before { content: "\f8cc"; }
diff --git a/ShengShengBuXi/wwwroot/css/fonts/bootstrap-icons.woff b/ShengShengBuXi/wwwroot/css/fonts/bootstrap-icons.woff
new file mode 100644
index 0000000..6e72a59
Binary files /dev/null and b/ShengShengBuXi/wwwroot/css/fonts/bootstrap-icons.woff differ
diff --git a/ShengShengBuXi/wwwroot/css/fonts/bootstrap-icons.woff2 b/ShengShengBuXi/wwwroot/css/fonts/bootstrap-icons.woff2
new file mode 100644
index 0000000..3b957d5
Binary files /dev/null and b/ShengShengBuXi/wwwroot/css/fonts/bootstrap-icons.woff2 differ