欢迎加入开源鸿蒙PC社区：
https://harmonypc.csdn.net/

atomgit仓库地址： https://atomgit.com/2401_83963238/TTSError

一、问题背景

在 HarmonyOS 应用开发中，TTS（Text-to-Speech）功能支持在线和离线两种语音合成模式。在线模式通过云端服务器进行语音合成，音质更好、支持更多语言和音色，但依赖网络连接；离线模式使用本地引擎，无需网络但功能受限。

当使用在线模式时，网络连接问题是最常见的故障原因。网络断开、超时、DNS 解析失败等问题都会导致 TTS 语音合成失败，返回错误码 3001（网络连接失败）或 3002（网络超时）。

本文基于项目中的 TTSNetworkError.ets 演示页面，深入分析 TTS 网络连接错误的各类场景，提供完整的网络状态管理、在线/离线模式切换方案。

二、TTS 网络连接错误概述

2.1 什么是 TTS 网络连接错误

TTS 网络连接错误是指在调用在线 TTS 引擎时，由于网络相关原因导致语音合成失败。这类错误通常发生在以下场景：

• 设备未连接网络
• 网络连接不稳定
• 服务器响应超时
• DNS 解析失败
• 网络权限未授予

2.2 在线模式与离线模式对比

特性	在线模式	离线模式
引擎创建参数	online: 1	online: 0
网络依赖	必须联网	无需联网
语音质量	高质量，支持多种音色	质量一般，音色有限
响应速度	依赖网络延迟	响应快速
语言支持	支持多种语言	仅支持预装语言
资源占用	占用网络带宽	占用本地存储
错误码 3001	可能发生	不会发生
错误码 3002	可能发生	不会发生

2.3 网络相关错误码

错误码	含义	常见原因
3001	网络连接失败	设备未联网、网络权限不足
3002	网络超时	服务器响应慢、网络不稳定
-1	引擎创建失败	可能是网络问题导致
100	网络错误	通用网络异常

三、核心代码深度解析

3.1 网络状态检查方法：checkNetwork

checkNetwork(): void {
  this.networkStatus = '模拟网络检查';
  this.addLog('网络状态: 演示模式（实际应用中应使用网络管理API）');
}

代码解析：

这个方法用于检查当前设备的网络连接状态。在演示页面中，它只是模拟了网络检查的过程，实际应用中应该使用 HarmonyOS 的网络管理 API。

实际应用中的网络检查实现：

import connection from '@ohos.net.connection';

class NetworkChecker {
  static async checkNetworkStatus(): Promise<NetworkStatus> {
    try {
      // 获取默认网络
      const netConnection = connection.createNetConnection();
      
      // 注册网络状态变化监听
      const networkState = await new Promise<connection.NetConnectionState>((resolve) => {
        netConnection.register((error: BusinessError, data: connection.NetConnectionState) => {
          if (error) {
            console.error('网络状态检查失败:', error);
            resolve(connection.NetConnectionState.NET_UNKNOWN);
          } else {
            resolve(data);
          }
        });
      });

      // 检查网络是否可用
      const isAvailable = await connection.hasDefaultNet();
      
      // 获取网络类型
      const netType = await connection.getNetType();

      return {
        isAvailable: isAvailable,
        netType: netType,
        state: networkState,
        timestamp: new Date().toISOString()
      };
    } catch (error) {
      console.error('网络检查异常:', error);
      return {
        isAvailable: false,
        netType: connection.NetType.NONE,
        state: connection.NetConnectionState.NET_UNKNOWN,
        timestamp: new Date().toISOString()
      };
    }
  }
}

interface NetworkStatus {
  isAvailable: boolean;
  netType: connection.NetType;
  state: connection.NetConnectionState;
  timestamp: string;
}

网络类型枚举：

网络类型	常量值	说明
NONE	0	无网络
MOBILE	1	移动数据
WIFI	2	Wi-Fi
ETHERNET	3	以太网
VPN	4	VPN
BLUETOOTH	5	蓝牙网络

使用示例：

async checkNetwork(): Promise<void> {
  const networkStatus = await NetworkChecker.checkNetworkStatus();
  
  if (networkStatus.isAvailable) {
    this.networkStatus = `已连接 (${this.getNetTypeName(networkStatus.netType)})`;
    this.addLog(`网络状态: 已连接，类型=${this.getNetTypeName(networkStatus.netType)}`);
  } else {
    this.networkStatus = '未连接';
    this.addLog('网络状态: 未连接，建议使用离线模式');
  }
}

private getNetTypeName(netType: connection.NetType): string {
  const typeNames: Record<number, string> = {
    [connection.NetType.NONE]: '无网络',
    [connection.NetType.MOBILE]: '移动数据',
    [connection.NetType.WIFI]: 'Wi-Fi',
    [connection.NetType.ETHERNET]: '以太网',
    [connection.NetType.VPN]: 'VPN',
    [connection.NetType.BLUETOOTH]: '蓝牙'
  };
  return typeNames[netType] || '未知';
}

3.2 在线语音合成方法：speakOnline

async speakOnline(): Promise<void> {
  // 设置初始状态
  this.statusText = '正在播放...';
  this.errorMessage = '';
  this.addLog('开始在线语音合成');

  // 检查网络状态
  this.checkNetwork();

  // 确保 TTS 引擎已初始化
  if (!await this.initializeTTS()) {
    this.statusText = '初始化失败';
    this.errorMessage = '无法初始化 TTS 引擎';
    return;
  }

  try {
    // 构建播放参数
    const extraParams: TTSSpeakExtraParams = new TTSSpeakExtraParams(
      0, 1.0, 1.0, 1.0, 'zh-CN', 'pcm', 3, 1
    );

    const speakParams: textToSpeech.SpeakParams = {
      requestId: `tts-${Date.now().toString()}`,
      extraParams: extraParams.toRecord()
    };

    // 执行在线语音合成
    this.ttsEngine!.speak('这是在线语音合成的测试文本。', speakParams);
    
    // 更新成功状态
    this.statusText = '播放成功';
    this.addLog('在线语音合成成功');
  } catch (error) {
    const err = error as BusinessError;
    this.statusText = '播放失败';
    this.errorMessage = `错误码: ${err.code}, 消息: ${err.message}`;
    this.addLog(`在线语音合成失败：${this.errorMessage}`);
  }
}

代码解析：

这个方法演示了在线语音合成的完整流程。关键点是在执行语音合成前检查网络状态。

在线语音合成流程图：

用户点击在线播放
    │
    ▼
检查网络状态
    │
    ├──网络未连接──▶ 提示用户，建议切换到离线模式
    │
    └──网络已连接
          │
          ▼
    初始化在线引擎 (online: 1)
          │
          ├──初始化失败──▶ 显示错误信息
          │
          └──初始化成功
                │
                ▼
          调用 speak() 方法
                │
                ├──播放成功──▶ 更新状态为"播放成功"
                │
                └──播放失败──▶ 捕获异常，显示错误码和消息

在线模式的优缺点：

优点：

1. 语音质量高：云端引擎提供更自然的语音效果
2. 音色丰富：支持多种音色和语言
3. 持续更新：云端模型会不断优化
4. 资源占用低：不需要本地存储大量语音数据

缺点：

1. 依赖网络：必须联网才能使用
2. 延迟较高：需要网络传输时间
3. 消耗流量：每次合成都会消耗网络流量
4. 隐私风险：文本内容会上传到服务器

3.3 离线语音合成方法：initializeOffline

async initializeOffline(): Promise<void> {
  this.statusText = '正在初始化...';
  this.errorMessage = '';
  this.addLog('尝试使用离线模式初始化');

  try {
    // 构建离线初始化参数
    const extraParams: TTSInitExtraParams = new TTSInitExtraParams(
      'interaction-broadcast',
      'CN',
      'EngineName'
    );

    const initParams: textToSpeech.CreateEngineParams = {
      language: 'zh-CN',
      person: 0,
      online: 0,  // 关键：设置为 0 表示离线模式
      extraParams: extraParams.toRecord()
    };

    // 创建离线 TTS 引擎
    this.ttsEngine = await textToSpeech.createEngine(initParams);

    if (this.ttsEngine) {
      this.isInitialized = true;
      this.statusText = '离线初始化成功';
      this.addLog('离线 TTS 引擎初始化成功');

      // 构建播放参数
      const offlineExtraParams: TTSSpeakExtraParams = new TTSSpeakExtraParams(
        0, 1.0, 1.0, 1.0, 'zh-CN', 'pcm', 3, 1
      );

      const speakParams: textToSpeech.SpeakParams = {
        requestId: `tts-${Date.now().toString()}`,
        extraParams: offlineExtraParams.toRecord()
      };

      // 执行离线语音合成
      this.ttsEngine.speak('这是离线语音合成的测试文本。', speakParams);
      this.statusText = '离线播放成功';
      this.addLog('离线语音合成成功');
    } else {
      this.statusText = '离线初始化失败';
      this.errorMessage = '离线引擎创建返回 null';
      this.addLog('离线 TTS 引擎初始化失败');
    }
  } catch (error) {
    const err = error as BusinessError;
    this.statusText = '离线初始化失败';
    this.errorMessage = `错误码: ${err.code}, 消息: ${err.message}`;
    this.addLog(`离线初始化失败：${this.errorMessage}`);
  }
}

代码解析：

这个方法演示了离线语音合成的完整流程。与在线模式的关键区别在于 online: 0 参数。

离线语音合成流程图：

用户点击离线播放
    │
    ▼
初始化离线引擎 (online: 0)
    │
    ├──初始化失败──▶ 显示错误信息（可能是系统不支持离线）
    │
    └──初始化成功
          │
          ▼
    调用 speak() 方法
          │
          ├──播放成功──▶ 更新状态为"离线播放成功"
          │
          └──播放失败──▶ 捕获异常，显示错误码和消息

离线模式的优缺点：

优点：

1. 无需网络：可以在任何环境下使用
2. 响应快速：本地合成，无网络延迟
3. 隐私安全：文本内容不上传到服务器
4. 节省流量：不消耗网络流量

缺点：

1. 语音质量一般：本地引擎效果不如云端
2. 音色有限：通常只有 1-2 种音色
3. 语言受限：仅支持系统预装的语言
4. 占用存储：需要本地存储语音数据

3.4 在线/离线模式切换策略

在实际应用中，应该根据网络状态自动切换在线/离线模式：

class TTSModeManager {
  private currentMode: 'online' | 'offline' = 'online';
  private engine: textToSpeech.TextToSpeechEngine | null = null;
  private isInitialized: boolean = false;

  async initializeWithAutoMode(): Promise<boolean> {
    // 检查网络状态
    const networkStatus = await NetworkChecker.checkNetworkStatus();
    
    // 根据网络状态选择模式
    if (networkStatus.isAvailable) {
      console.info('网络可用，使用在线模式');
      this.currentMode = 'online';
      return await this.initializeOnline();
    } else {
      console.info('网络不可用，使用离线模式');
      this.currentMode = 'offline';
      return await this.initializeOffline();
    }
  }

  private async initializeOnline(): Promise<boolean> {
    try {
      const extraParams = new TTSInitExtraParams(
        'interaction-broadcast',
        'CN',
        'EngineName'
      );

      const initParams: textToSpeech.CreateEngineParams = {
        language: 'zh-CN',
        person: 0,
        online: 1,  // 在线模式
        extraParams: extraParams.toRecord()
      };

      this.engine = await textToSpeech.createEngine(initParams);
      this.isInitialized = true;
      return true;
    } catch (error) {
      console.error('在线模式初始化失败:', error);
      // 在线模式失败，尝试降级到离线模式
      console.warn('在线模式失败，尝试降级到离线模式');
      return await this.initializeOffline();
    }
  }

  private async initializeOffline(): Promise<boolean> {
    try {
      const extraParams = new TTSInitExtraParams(
        'interaction-broadcast',
        'CN',
        'EngineName'
      );

      const initParams: textToSpeech.CreateEngineParams = {
        language: 'zh-CN',
        person: 0,
        online: 0,  // 离线模式
        extraParams: extraParams.toRecord()
      };

      this.engine = await textToSpeech.createEngine(initParams);
      this.isInitialized = true;
      return true;
    } catch (error) {
      console.error('离线模式初始化失败:', error);
      return false;
    }
  }

  getCurrentMode(): 'online' | 'offline' {
    return this.currentMode;
  }
}

四、网络状态管理与重试机制

4.1 网络状态监听器

import connection from '@ohos.net.connection';

class NetworkStateListener {
  private netConnection: connection.NetConnection | null = null;
  private onNetworkChange: ((isAvailable: boolean) => void) | null = null;

  startListening(callback: (isAvailable: boolean) => void): void {
    this.onNetworkChange = callback;
    
    // 创建网络连接对象
    this.netConnection = connection.createNetConnection();
    
    // 注册网络状态变化监听
    this.netConnection.register((error: BusinessError, data: connection.NetConnectionState) => {
      if (error) {
        console.error('网络状态监听失败:', error);
        return;
      }

      // 检查网络是否可用
      connection.hasDefaultNet().then((isAvailable: boolean) => {
        console.info(`网络状态变化: ${isAvailable ? '已连接' : '已断开'}`);
        if (this.onNetworkChange) {
          this.onNetworkChange(isAvailable);
        }
      }).catch((err: BusinessError) => {
        console.error('检查网络可用性失败:', err);
      });
    });
  }

  stopListening(): void {
    if (this.netConnection) {
      this.netConnection.unregister();
      this.netConnection = null;
    }
    this.onNetworkChange = null;
  }
}

4.2 带重试机制的 TTS 管理器

class RetryTTSManager {
  private engine: textToSpeech.TextToSpeechEngine | null = null;
  private isInitialized: boolean = false;
  private maxRetries: number = 3;
  private retryDelay: number = 2000; // 2 秒

  async speakWithRetry(text: string): Promise<boolean> {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      const success = await this.speakOnce(text);
      
      if (success) {
        console.info('语音播放成功');
        return true;
      }

      // 检查是否应该重试
      if (attempt < this.maxRetries - 1) {
        const delay = this.retryDelay * Math.pow(2, attempt); // 指数退避
        console.warn(`播放失败，第 ${attempt + 1} 次重试，延迟 ${delay}ms`);
        await this.delay(delay);
      }
    }

    console.error('播放失败，已达到最大重试次数');
    return false;
  }

  private async speakOnce(text: string): Promise<boolean> {
    try {
      // 确保引擎已初始化
      if (!await this.initialize()) {
        return false;
      }

      // 构建播放参数
      const speakParams: textToSpeech.SpeakParams = {
        requestId: `tts-${Date.now().toString()}`,
        extraParams: {
          queueMode: 0,
          speed: 1.0,
          volume: 1.0,
          pitch: 1.0,
          languageContext: 'zh-CN',
          audioType: 'pcm',
          soundChannel: 3,
          playType: 1
        }
      };

      // 执行播放
      this.engine!.speak(text, speakParams);
      return true;
    } catch (error) {
      const err = error as BusinessError;
      
      // 检查错误码，判断是否应该重试
      if (this.shouldRetry(err.code)) {
        console.warn(`播放失败（可重试）: 错误码=${err.code}, 消息=${err.message}`);
        return false;
      } else {
        console.error(`播放失败（不可重试）: 错误码=${err.code}, 消息=${err.message}`);
        throw error; // 不可重试的错误，直接抛出
      }
    }
  }

  private shouldRetry(errorCode: number | undefined): boolean {
    // 网络相关错误可以重试
    const retryableErrors = [3001, 3002, -1, 100];
    return errorCode !== undefined && retryableErrors.includes(errorCode);
  }

  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  private async initialize(): Promise<boolean> {
    if (this.isInitialized && this.engine) {
      return true;
    }

    try {
      const extraParams = new TTSInitExtraParams(
        'interaction-broadcast',
        'CN',
        'EngineName'
      );

      const initParams: textToSpeech.CreateEngineParams = {
        language: 'zh-CN',
        person: 0,
        online: 1,
        extraParams: extraParams.toRecord()
      };

      this.engine = await textToSpeech.createEngine(initParams);
      this.isInitialized = true;
      return true;
    } catch (error) {
      console.error('引擎初始化失败:', error);
      return false;
    }
  }
}

4.3 网络恢复后的自动重试

class AutoRetryTTSManager {
  private engine: textToSpeech.TextToSpeechEngine | null = null;
  private isInitialized: boolean = false;
  private networkListener: NetworkStateListener = new NetworkStateListener();
  private pendingText: string | null = null;

  start(): void {
    // 开始监听网络状态
    this.networkListener.startListening((isAvailable: boolean) => {
      if (isAvailable && this.pendingText) {
        console.info('网络恢复，重试播放');
        this.speak(this.pendingText);
        this.pendingText = null;
      }
    });
  }

  stop(): void {
    this.networkListener.stopListening();
  }

  async speak(text: string): Promise<boolean> {
    try {
      // 确保引擎已初始化
      if (!await this.initialize()) {
        return false;
      }

      // 构建播放参数
      const speakParams: textToSpeech.SpeakParams = {
        requestId: `tts-${Date.now().toString()}`,
        extraParams: {
          queueMode: 0,
          speed: 1.0,
          volume: 1.0,
          pitch: 1.0,
          languageContext: 'zh-CN',
          audioType: 'pcm',
          soundChannel: 3,
          playType: 1
        }
      };

      // 执行播放
      this.engine!.speak(text, speakParams);
      return true;
    } catch (error) {
      const err = error as BusinessError;
      
      // 检查是否是网络错误
      if (this.isNetworkError(err.code)) {
        console.warn('网络错误，等待网络恢复后重试');
        this.pendingText = text; // 保存待播放的文本
        return false;
      } else {
        console.error('非网络错误:', error);
        throw error;
      }
    }
  }

  private isNetworkError(errorCode: number | undefined): boolean {
    return errorCode === 3001 || errorCode === 3002;
  }

  private async initialize(): Promise<boolean> {
    if (this.isInitialized && this.engine) {
      return true;
    }

    try {
      const extraParams = new TTSInitExtraParams(
        'interaction-broadcast',
        'CN',
        'EngineName'
      );

      const initParams: textToSpeech.CreateEngineParams = {
        language: 'zh-CN',
        person: 0,
        online: 1,
        extraParams: extraParams.toRecord()
      };

      this.engine = await textToSpeech.createEngine(initParams);
      this.isInitialized = true;
      return true;
    } catch (error) {
      console.error('引擎初始化失败:', error);
      return false;
    }
  }
}

五、完整的错误处理方案

5.1 统一的网络错误处理器

class TTSNetworkErrorHandler {
  static handleNetworkError(error: BusinessError): NetworkErrorInfo {
    const errorInfo: NetworkErrorInfo = {
      code: error.code ?? -1,
      message: error.message ?? '未知错误',
      type: this.getErrorType(error.code),
      suggestion: this.getSuggestion(error.code),
      shouldRetry: this.shouldRetry(error.code),
      timestamp: new Date().toISOString()
    };

    console.error(`[TTS Network Error] 代码=${errorInfo.code}, 类型=${errorInfo.type}`);
    console.error(`建议: ${errorInfo.suggestion}`);
    
    return errorInfo;
  }

  private static getErrorType(code: number | undefined): string {
    switch (code) {
      case 3001:
        return '网络连接失败';
      case 3002:
        return '网络超时';
      case -1:
        return '引擎创建失败';
      case 100:
        return '通用网络错误';
      default:
        return '未知错误';
    }
  }

  private static getSuggestion(code: number | undefined): string {
    switch (code) {
      case 3001:
        return '请检查网络连接是否正常，或切换到离线模式';
      case 3002:
        return '网络响应超时，请检查网络质量或稍后重试';
      case -1:
        return '引擎创建失败，可能是网络问题，建议切换到离线模式';
      case 100:
        return '网络异常，请检查网络连接';
      default:
        return '未知错误，请查看详细日志';
    }
  }

  private static shouldRetry(code: number | undefined): boolean {
    // 网络相关错误都可以重试
    return [3001, 3002, -1, 100].includes(code ?? -1);
  }
}

interface NetworkErrorInfo {
  code: number;
  message: string;
  type: string;
  suggestion: string;
  shouldRetry: boolean;
  timestamp: string;
}

5.2 完整的 TTS 管理器实现

class CompleteTTSManager {
  private engine: textToSpeech.TextToSpeechEngine | null = null;
  private isInitialized: boolean = false;
  private currentMode: 'online' | 'offline' = 'online';
  private networkListener: NetworkStateListener = new NetworkStateListener();

  async initialize(): Promise<boolean> {
    // 检查网络状态
    const networkStatus = await NetworkChecker.checkNetworkStatus();
    
    // 根据网络状态选择模式
    if (networkStatus.isAvailable) {
      this.currentMode = 'online';
      return await this.initializeOnline();
    } else {
      this.currentMode = 'offline';
      return await this.initializeOffline();
    }
  }

  private async initializeOnline(): Promise<boolean> {
    try {
      const extraParams = new TTSInitExtraParams(
        'interaction-broadcast',
        'CN',
        'EngineName'
      );

      const initParams: textToSpeech.CreateEngineParams = {
        language: 'zh-CN',
        person: 0,
        online: 1,
        extraParams: extraParams.toRecord()
      };

      this.engine = await textToSpeech.createEngine(initParams);
      this.isInitialized = true;
      return true;
    } catch (error) {
      const err = error as BusinessError;
      const errorInfo = TTSNetworkErrorHandler.handleNetworkError(err);
      
      // 在线模式失败，尝试降级到离线模式
      if (errorInfo.shouldRetry) {
        console.warn('在线模式失败，尝试降级到离线模式');
        this.currentMode = 'offline';
        return await this.initializeOffline();
      }
      
      return false;
    }
  }

  private async initializeOffline(): Promise<boolean> {
    try {
      const extraParams = new TTSInitExtraParams(
        'interaction-broadcast',
        'CN',
        'EngineName'
      );

      const initParams: textToSpeech.CreateEngineParams = {
        language: 'zh-CN',
        person: 0,
        online: 0,
        extraParams: extraParams.toRecord()
      };

      this.engine = await textToSpeech.createEngine(initParams);
      this.isInitialized = true;
      return true;
    } catch (error) {
      const err = error as BusinessError;
      TTSNetworkErrorHandler.handleNetworkError(err);
      return false;
    }
  }

  async speak(text: string): Promise<boolean> {
    if (!await this.initialize()) {
      return false;
    }

    try {
      const speakParams: textToSpeech.SpeakParams = {
        requestId: `tts-${Date.now().toString()}`,
        extraParams: {
          queueMode: 0,
          speed: 1.0,
          volume: 1.0,
          pitch: 1.0,
          languageContext: 'zh-CN',
          audioType: 'pcm',
          soundChannel: 3,
          playType: 1
        }
      };

      this.engine!.speak(text, speakParams);
      return true;
    } catch (error) {
      const err = error as BusinessError;
      const errorInfo = TTSNetworkErrorHandler.handleNetworkError(err);
      
      // 如果是在线模式失败，尝试切换到离线模式
      if (this.currentMode === 'online' && errorInfo.shouldRetry) {
        console.warn('在线模式播放失败，尝试切换到离线模式');
        this.currentMode = 'offline';
        await this.initializeOffline();
        return await this.speak(text);
      }
      
      return false;
    }
  }

  getCurrentMode(): 'online' | 'offline' {
    return this.currentMode;
  }
}

六、权限配置

TTS 在线模式需要网络权限，需要在 module.json5 中配置：

{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.INTERNET",
        "reason": "$string:permission_internet_reason",
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "always"
        }
      },
      {
        "name": "ohos.permission.GET_NETWORK_INFO",
        "reason": "$string:permission_network_info_reason",
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "always"
        }
      }
    ]
  }
}

七、总结

TTS 网络连接错误是 HarmonyOS 开发中的常见问题，但通过合理的网络状态管理和在线/离线模式切换策略，可以提供稳定可靠的语音合成体验。

核心代码模块解析：

1. checkNetwork - 网络状态检查方法，实际应用中应使用 @ohos.net.connection API
2. speakOnline - 在线语音合成方法，依赖网络连接
3. initializeOffline - 离线语音合成方法，无需网络

关键解决方案：

问题	解决方案
网络连接失败	使用 NetworkChecker 检查网络状态
在线模式不可用	自动降级到离线模式
网络超时	实现指数退避的重试机制
网络恢复	使用 NetworkStateListener 监听网络状态变化

最佳实践：

1. 播放前检查网络：在调用 speak() 前检查网络状态
2. 支持在线/离线切换：根据网络状态自动选择合适的模式
3. 实现重试机制：对于网络错误，实现带指数退避的重试
4. 监听网络状态：监听网络状态变化，网络恢复后自动重试
5. 提供用户反馈：清晰地向用户展示当前模式和错误信息

通过这些策略，开发者可以构建出在各种网络环境下都能正常工作的 TTS 功能。