Unity安卓打包RT-Voice无声？配置Google TTS引擎全流程解决

1. 项目概述与问题定位

最近在做一个Unity AR项目，需要实现语音播报功能，为了快速开发，我选择了RT-Voice这款在Unity社区里口碑不错的语音合成插件。在编辑器里测试一切正常，语音清晰流畅，但一到安卓真机上打包运行，就彻底“哑火”了，没有任何声音输出。这个问题困扰了我好几天，经过一番折腾和排查，终于找到了症结所在并成功解决。今天就把这个“坑”的来龙去脉、排查思路以及最终的解决方案——配置Google TTS（Text-to-Speech）引擎的全流程，完整地分享出来。如果你也遇到了Unity项目（尤其是AR项目）在安卓打包后RT-Voice没声音的问题，或者对如何在移动端集成稳定的TTS功能感兴趣，这篇实战记录应该能给你提供直接的参考。

简单来说，RT-Voice在PC或编辑器环境下，通常依赖系统自带的语音合成引擎（比如Windows的SAPI）。但当你的应用打包到安卓设备上时，这个“系统引擎”就变成了一个不确定因素。不同品牌、不同型号、不同系统版本的安卓手机，其内置的TTS引擎千差万别，有的甚至没有预装可用的中文TTS引擎。RT-Voice插件在调用系统TTS服务时，如果目标设备上没有合适的引擎或引擎未正确配置，就会导致无声。因此，解决方案的核心在于：为你的应用提供一个 不依赖于设备预装TTS引擎的、稳定可靠的语音合成方案 。而Google TTS正是这样一个跨设备兼容性极佳的解决方案。

2. RT-Voice插件原理与安卓无声根源深析

要解决问题，必须先理解问题是怎么产生的。RT-Voice插件本身是一个封装层，它并不是一个独立的语音合成器。它的工作原理是，当你在代码中调用 RT-Voice 的播放接口时，插件会去调用当前运行平台（Windows, Android, iOS等）系统原生的语音合成（TTS）API。

2.1 编辑器与真机环境的本质差异

在Unity编辑器中（通常是在Windows或macOS上开发），你的系统已经内置了成熟且功能完整的TTS引擎。例如Windows的 System.Speech.Synthesis 命名空间下的API。RT-Voice在编辑器模式下，就是通过调用这些本地API来发声的，所以测试时一切正常。

然而，当你将项目打包成APK并安装到安卓手机上时，运行环境发生了根本性变化：

1. 操作系统 ：从Windows/macOS变成了Android。
2. 系统API ：从Windows SAPI或macOS NSSpeechSynthesizer变成了Android的 android.speech.tts.TextToSpeech 。
3. 依赖引擎 ：从PC系统内置的稳定引擎，变成了手机厂商预装的、可能被阉割或修改过的TTS引擎。

2.2 安卓TTS生态的碎片化“深坑”

安卓的开放性带来了设备的多样性，也带来了TTS服务的碎片化问题，这是导致无声的 最主要根源 ：

1. 引擎缺失 ：许多国产手机为了精简系统或降低成本，可能移除了Google原生的TTS服务（Google Text-to-speech Engine），或者仅保留了非常基础的引擎，不支持中文或你需要的语言。
2. 引擎未激活/未设置 ：即使设备有TTS引擎，也可能没有被设置为默认引擎，或者没有下载对应的语音数据包。用户通常不会去系统设置里专门配置这个。
3. 权限问题 ：从Android 6.0 (API level 23)开始，某些系统TTS的调用可能需要运行时权限，如果插件或你的应用没有正确处理，会导致初始化失败。
4. 初始化异步性 ：Android的 TextToSpeech 引擎初始化是异步的。插件可能在引擎还未初始化完成（ OnInit 回调未返回 SUCCESS ）时就尝试播放，导致失败。这个时机在性能不同的设备上表现不一，增加了问题的随机性。
5. AR项目特有的资源占用 ：AR应用通常需要同时调用摄像头、进行图像识别与渲染，CPU和内存资源非常紧张。系统TTS引擎在资源不足时，可能会被系统“静默”地终止或拒绝服务，而你的应用却收不到明确的错误回调。

实操心得 ：遇到打包后没声音，首先不要怀疑插件代码。绝大多数情况是 运行环境不满足 。我的排查第一步永远是：在出问题的安卓手机上，打开“设置” -> “系统” -> “语言与输入法” -> “文字转语音(TTS)输出”，查看默认引擎是什么，以及首选引擎是否有可用的语音数据。很多时候，这里显示的是“未安装语音数据”或者是一个你不认识的引擎。

3. 解决方案选型：为什么是Google TTS？

面对安卓TTS的碎片化问题，通常有几种解决思路：

1. 提示用户手动安装配置 ：在应用内检测，如果TTS不可用，则引导用户去系统设置或Google Play商店下载安装语音包。 缺点 ：用户体验极差，操作路径长，很多用户会直接放弃。
2. 集成离线TTS引擎 ：将一套完整的离线TTS引擎（如科大讯飞、百度语音的离线SDK）打包进APK。 缺点 ：显著增加APK体积（动辄几十MB甚至上百MB），增加集成复杂度，可能涉及商业授权。
3. 使用在线TTS服务 ：通过API调用云端语音合成服务（如阿里云、腾讯云的TTS），将生成的音频文件下载播放。 缺点 ：依赖网络，有延迟，可能产生费用。
4. 集成Google TTS并确保其可用 ：这是我认为在 兼容性、音质、体积、易用性 之间取得最佳平衡的方案。

选择Google TTS的核心理由 ：

• 极高的市场覆盖率 ：Google Play服务在绝大多数海外安卓机和很多国内机型上都是预装的，其包含的Google TTS引擎是质量最高、支持语言最全的引擎之一。
• 系统级集成 ：它作为系统服务存在，可以被所有应用调用。一旦在设备上可用，其稳定性远超第三方应用自带的引擎。
• 按需下载语音包 ：我们可以通过代码引导用户下载所需的语音数据包，这个过程可以封装在应用内，体验相对流畅。
• 对开发者友好 ：Android原生提供了完善的 TextToSpeech API来与Google TTS交互，Unity可以通过Android Java插件（AndroidJavaClass/AndroidJavaObject）方便地调用。

对于RT-Voice插件 ：我们的目标不是替换RT-Voice，而是 为RT-Voice提供一个稳定、可靠的安卓后端 。即，在安卓平台上，让RT-Voice去调用我们配置好的Google TTS服务，而不是那个不可靠的“默认系统引擎”。

4. 安卓平台Google TTS配置全流程实操

下面进入最关键的实操部分。我们将一步步为Unity项目配置Google TTS，并确保RT-Voice能正确调用它。整个流程分为：Unity项目配置、Android Studio模块开发、Unity与安卓代码交互、以及RT-Voice的适配调用。

4.1 Unity项目基础环境配置

在开始写代码之前，确保你的Unity项目已经为安卓开发做好了准备。

1. 安装必要的SDK/NDK/JDK ：打开Unity Hub，在安装的Unity版本模块中，确保已安装 Android Build Support 以及其下的 Android SDK & NDK Tools 和 OpenJDK 。你也可以使用自己本地安装的JDK和SDK，在 Edit -> Preferences -> External Tools 中指定路径。
2. 切换构建平台 ：打开 File -> Build Settings ，选择 Android 平台，点击 Switch Platform 。
3. 修改Player Settings ：
   • Other Settings 部分：
     • Package Name ：设置一个唯一的反向域名标识（如 com.yourcompany.yourapp ）。
     • Minimum API Level ：建议设置为 Android 5.1 (API level 22) 或更高，以覆盖更多设备。Google TTS相关API在较旧版本上可能支持不全。
     • Target API Level ：设置为你测试设备对应的API级别或最新的稳定版。
   • Publishing Settings 部分：
     • 勾选 Custom Main Gradle Template 和 Custom Launcher Gradle Template 。这是关键一步，我们需要修改Gradle配置来引入必要的依赖。

4.2 创建Android TTS Helper插件

由于RT-Voice可能没有直接提供配置Google TTS的接口，我们需要自己创建一个Android原生插件（Android Plugin）来封装TTS功能，然后在Unity C#脚本中调用它。

步骤一：创建Android Studio模块（或直接编写Java代码） 最简单的方式是直接在Unity项目的 Assets/Plugins/Android 目录下创建必要的文件。你需要创建以下结构：

Assets/
└── Plugins/
    └── Android/
        ├── AndroidManifest.xml
        ├── mainTemplate.gradle (由Unity生成，我们需要修改它)
        ├── launcherTemplate.gradle (由Unity生成，我们需要修改它)
        └── com/
            └── yourcompany/
                └── ttshelper/
                    ├── TTSHelper.java
                    └── ... (其他可能的资源文件)

步骤二：编写Android Java插件代码 ( TTSHelper.java ) 这个类的核心任务是：初始化Google TTS引擎，检查并下载语音数据，提供简单的播放接口。

package com.yourcompany.ttshelper;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.speech.tts.TextToSpeech;
import android.speech.tts.UtteranceProgressListener;
import android.util.Log;
import java.util.HashMap;
import java.util.Locale;

public class TTSHelper implements TextToSpeech.OnInitListener {
    private static final String TAG = "UnityTTSHelper";
    private static TTSHelper instance;
    private TextToSpeech ttsEngine;
    private Activity unityActivity;
    private boolean isInitialized = false;
    private InitCallback initCallback;
    private SpeakCallback speakCallback;

    // 回调接口，用于与Unity通信
    public interface InitCallback {
        void onInitialized(boolean success, String message);
    }
    public interface SpeakCallback {
        void onSpeakStart(String utteranceId);
        void onSpeakDone(String utteranceId);
        void onSpeakError(String utteranceId, String error);
    }

    // 单例模式获取实例
    public static TTSHelper getInstance(Activity activity) {
        if (instance == null) {
            instance = new TTSHelper(activity);
        }
        return instance;
    }

    private TTSHelper(Activity activity) {
        this.unityActivity = activity;
        // 注意：这里我们显式指定使用Google的TTS引擎。
        // 参数“com.google.android.tts”是Google TTS引擎的包名。
        Intent checkIntent = new Intent();
        checkIntent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
        // 可以启动一个Activity来检查，但我们选择直接初始化并处理错误。
        // 更优的做法是先检查，再初始化。这里为了简化，直接初始化并在onInit里处理。
        ttsEngine = new TextToSpeech(unityActivity, this, "com.google.android.tts");
    }

    // TextToSpeech.OnInitListener 回调
    @Override
    public void onInit(int status) {
        Log.d(TAG, "TTS Engine onInit, status: " + status);
        if (status == TextToSpeech.SUCCESS) {
            // 设置语言，这里以中文为例
            int result = ttsEngine.setLanguage(Locale.CHINESE);
            if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) {
                Log.e(TAG, "Chinese language is not supported or missing data.");
                // 语言数据缺失，引导用户下载
                Intent installIntent = new Intent();
                installIntent.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
                installIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                unityActivity.startActivity(installIntent);
                if (initCallback != null) {
                    initCallback.onInitialized(false, "Language pack missing, launched installer.");
                }
                isInitialized = false;
            } else {
                // 初始化成功
                isInitialized = true;
                Log.i(TAG, "TTS Engine initialized successfully.");
                if (initCallback != null) {
                    initCallback.onInitialized(true, "TTS Ready.");
                }
                // 设置播放进度监听器
                ttsEngine.setOnUtteranceProgressListener(new UtteranceProgressListener() {
                    @Override
                    public void onStart(String utteranceId) {
                        Log.d(TAG, "Speak started: " + utteranceId);
                        if (speakCallback != null) {
                            unityActivity.runOnUiThread(() -> speakCallback.onSpeakStart(utteranceId));
                        }
                    }
                    @Override
                    public void onDone(String utteranceId) {
                        Log.d(TAG, "Speak done: " + utteranceId);
                        if (speakCallback != null) {
                            unityActivity.runOnUiThread(() -> speakCallback.onSpeakDone(utteranceId));
                        }
                    }
                    @Override
                    public void onError(String utteranceId, int errorCode) {
                        Log.e(TAG, "Speak error: " + utteranceId + ", code: " + errorCode);
                        if (speakCallback != null) {
                            unityActivity.runOnUiThread(() -> speakCallback.onSpeakError(utteranceId, "ErrorCode: " + errorCode));
                        }
                    }
                });
            }
        } else {
            Log.e(TAG, "TTS Engine initialization failed.");
            if (initCallback != null) {
                initCallback.onInitialized(false, "Init failed with status: " + status);
            }
            isInitialized = false;
        }
    }

    // 供Unity调用的初始化方法
    public void initialize(InitCallback callback) {
        this.initCallback = callback;
        // 初始化已在构造函数中开始，这里只需等待回调。
        // 如果已经初始化成功，直接回调。
        if (isInitialized && initCallback != null) {
            initCallback.onInitialized(true, "Already initialized.");
        }
    }

    // 供Unity调用的播放语音方法
    public void speakText(String text, String utteranceId, SpeakCallback callback) {
        this.speakCallback = callback;
        if (!isInitialized || ttsEngine == null) {
            Log.e(TAG, "TTS Engine is not initialized.");
            if (speakCallback != null) {
                speakCallback.onSpeakError(utteranceId, "Engine not initialized.");
            }
            return;
        }
        // 使用HashMap传递参数，UtteranceId用于回调识别
        HashMap<String, String> params = new HashMap<>();
        params.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, utteranceId);
        // 这里使用QUEUE_ADD模式，将语音加入播放队列。使用QUEUE_FLUSH则会打断当前播放。
        int speakResult = ttsEngine.speak(text, TextToSpeech.QUEUE_ADD, params, utteranceId);
        if (speakResult != TextToSpeech.SUCCESS) {
            Log.e(TAG, "Speak failed immediately with code: " + speakResult);
            if (speakCallback != null) {
                speakCallback.onSpeakError(utteranceId, "Speak failed: " + speakResult);
            }
        }
    }

    // 停止播放
    public void stopSpeaking() {
        if (ttsEngine != null) {
            ttsEngine.stop();
        }
    }

    // 释放资源
    public void shutdown() {
        if (ttsEngine != null) {
            ttsEngine.stop();
            ttsEngine.shutdown();
            ttsEngine = null;
        }
        isInitialized = false;
        instance = null;
    }
}

步骤三：配置AndroidManifest.xml 在 Assets/Plugins/Android/AndroidManifest.xml 中，确保声明了必要的权限（虽然TTS本身不一定需要，但AR项目通常需要摄像头等权限）。一个基础的示例如下：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.yourcompany.yourapp">
    <!-- 如果你的应用需要网络功能来下载语音数据（虽然不是必须，但推荐），可以添加网络权限 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <!-- ARCore通常需要相机权限 -->
    <uses-permission android:name="android.permission.CAMERA" />
    <!-- 如果你的应用目标API级别>=23，还需要在运行时请求相机权限 -->

    <application
        android:theme="@style/UnityThemeSelector"
        android:icon="@mipmap/app_icon"
        android:label="@string/app_name">
        <!-- Unity Player Activity -->
        <activity android:name="com.unity3d.player.UnityPlayerActivity"
                  android:configChanges="orientation|keyboardHidden|screenSize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
            <meta-data android:name="unityplayer.UnityActivity" android:value="true" />
        </activity>
        <!-- 可以在这里添加其他Activity或Service -->
    </application>
</manifest>

注意 ：如果你的项目中没有这个文件，Unity在打包时会自动生成一个默认的。但如果你想添加自定义配置（比如后面提到的 uses-feature ），最好自己维护一份，并放在 Plugins/Android 目录下，Unity在打包时会将其合并到最终的Manifest中。

步骤四：修改Gradle模板以添加依赖 这是确保Google TTS引擎可用的关键。我们需要修改Unity生成的Gradle模板文件，添加对Google Play服务中TTS库的依赖。

1. 找到并打开 Assets/Plugins/Android/mainTemplate.gradle 文件（如果你之前勾选了 Custom Main Gradle Template ，它就会存在）。
2. 在 dependencies 块内，添加以下依赖：

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    // 其他Unity相关的依赖...
    
    // 添加Google Play服务TTS库的依赖
    // 使用一个较新且稳定的版本，例如 20.0.5
    implementation 'com.google.android.gms:play-services-texttospeech:20.0.5'
    
    // 如果你的项目还用到其他Google Play服务组件，也可以一并添加
    // implementation 'com.google.android.gms:play-services-auth:20.7.0'
}

3. 同样，检查 launcherTemplate.gradle ，通常不需要修改，但确保其中没有冲突的配置。

4.3 Unity C# 桥接脚本编写

现在，我们需要在Unity中编写C#脚本，通过Android Java Native Interface (JNI)来调用我们刚刚创建的 TTSHelper 类。

创建一个名为 AndroidTTSManager.cs 的脚本：

using UnityEngine;
using System;
using System.Runtime.InteropServices;

public class AndroidTTSManager : MonoBehaviour
{
    private static AndroidTTSManager _instance;
    public static AndroidTTSManager Instance
    {
        get
        {
            if (_instance == null)
            {
                GameObject go = new GameObject("AndroidTTSManager");
                _instance = go.AddComponent<AndroidTTSManager>();
                DontDestroyOnLoad(go);
            }
            return _instance;
        }
    }

    private AndroidJavaObject ttsHelper = null;
    private AndroidJavaObject activityContext = null;

    // 定义与Java端匹配的回调委托
    public delegate void OnInitDelegate(bool success, string message);
    public delegate void OnSpeakStartDelegate(string utteranceId);
    public delegate void OnSpeakDoneDelegate(string utteranceId);
    public delegate void OnSpeakErrorDelegate(string utteranceId, string error);

    private OnInitDelegate onInitializedCallback;
    private OnSpeakStartDelegate onSpeakStartCallback;
    private OnSpeakDoneDelegate onSpeakDoneCallback;
    private OnSpeakErrorDelegate onSpeakErrorCallback;

    void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Destroy(this.gameObject);
            return;
        }
        _instance = this;
        InitializeAndroidTTS();
    }

    void InitializeAndroidTTS()
    {
        // 获取当前Unity的Activity上下文
        using (AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        {
            activityContext = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
        }

        if (activityContext == null)
        {
            Debug.LogError("Failed to get Unity Activity Context.");
            return;
        }

        // 调用Java单例方法获取TTSHelper实例
        try
        {
            using (AndroidJavaClass ttsHelperClass = new AndroidJavaClass("com.yourcompany.ttshelper.TTSHelper"))
            {
                // 调用静态方法 getInstance(Activity activity)
                ttsHelper = ttsHelperClass.CallStatic<AndroidJavaObject>("getInstance", activityContext);
                if (ttsHelper == null)
                {
                    Debug.LogError("Failed to get TTSHelper instance.");
                    return;
                }
                Debug.Log("Android TTSHelper instance obtained.");
            }
        }
        catch (Exception e)
        {
            Debug.LogError("Exception when initializing Android TTS: " + e.Message);
        }
    }

    // 初始化TTS引擎，并设置回调
    public void InitializeTTS(OnInitDelegate onInit)
    {
        if (ttsHelper == null)
        {
            Debug.LogError("TTSHelper is not available. Call InitializeAndroidTTS first.");
            onInit?.Invoke(false, "TTSHelper not available");
            return;
        }
        this.onInitializedCallback = onInit;

        // 创建Java端的回调代理对象
        AndroidJavaObject initCallback = new AndroidJavaObject("com.yourcompany.ttshelper.TTSHelper$InitCallback");
        // 这里需要用到JNI来设置回调方法，一种更直接的方式是在Java端提供设置回调的方法。
        // 为了简化，我们可以修改Java代码，增加一个setCallback方法，或者在这里使用JNI反射调用。
        // 下面展示一种通过JNI直接调用Java方法的替代方案（假设Java端有initialize(InitCallback)方法）：
        // 由于直接传递Java对象回调比较复杂，我们可以修改设计，在C#端轮询状态，或者通过SendMessage到GameObject。
        // 这里采用一个简化版：在Java端初始化完成后，通过UnitySendMessage通知C#。
        // 我们需要修改TTSHelper.java，在onInit成功或失败时，调用UnityPlayer.UnitySendMessage。
    }

    // 简化版：直接调用speak，假设初始化是异步完成的，在Awake中已经开始初始化。
    public void Speak(string text, string utteranceId = "defaultUtterance",
                      OnSpeakStartDelegate onStart = null,
                      OnSpeakDoneDelegate onDone = null,
                      OnSpeakErrorDelegate onError = null)
    {
        if (ttsHelper == null)
        {
            Debug.LogError("TTSHelper is not available.");
            onError?.Invoke(utteranceId, "TTSHelper not available");
            return;
        }
        this.onSpeakStartCallback = onStart;
        this.onSpeakDoneCallback = onDone;
        this.onSpeakErrorCallback = onError;

        try
        {
            // 同样，需要Java端提供带有回调的speak方法。这里先演示无回调的调用。
            // 假设我们修改了Java代码，添加了speakText(text, utteranceId, callback)方法。
            // 我们需要使用AndroidJavaProxy来创建Java接口的实例。
            // 由于代码较长，这里给出关键思路：
            // 1. 在C#中定义一个类继承AndroidJavaProxy，实现Java回调接口。
            // 2. 创建该代理对象。
            // 3. 调用ttsHelper.Call("speakText", text, utteranceId, proxyObject);

            // 以下是伪代码/思路，实际实现需要与Java端严格匹配：
            /*
            class TtsSpeakCallbackProxy : AndroidJavaProxy {
                public TtsSpeakCallbackProxy() : base("com.yourcompany.ttshelper.TTSHelper$SpeakCallback") {}
                public void onSpeakStart(string uid) { /* 转发到C#委托 */ }
                public void onSpeakDone(string uid) { /* 转发到C#委托 */ }
                public void onSpeakError(string uid, string err) { /* 转发到C#委托 */ }
            }
            var callbackProxy = new TtsSpeakCallbackProxy();
            ttsHelper.Call("speakText", text, utteranceId, callbackProxy);
            */
            // 作为临时测试，可以先调用一个没有回调的简单版本。
            ttsHelper.Call("speakText", text, utteranceId);
            Debug.Log($"Called TTS speak with text: {text}");
        }
        catch (Exception e)
        {
            Debug.LogError($"Exception when speaking: {e.Message}");
            onError?.Invoke(utteranceId, e.Message);
        }
    }

    public void Stop()
    {
        ttsHelper?.Call("stopSpeaking");
    }

    void OnDestroy()
    {
        ttsHelper?.Call("shutdown");
        ttsHelper?.Dispose();
    }
}

重要提示 ：上面的C#脚本是一个 框架性示例 ，它展示了基本的JNI调用流程。但完整的、稳定的回调机制（从Java到C#）需要更精细的设计，通常有两种方式：

1. 使用 AndroidJavaProxy ：如上文伪代码所示，在C#端实现Java接口，将实例传递给Java端。这是最规范的方式。
2. 使用 UnityPlayer.UnitySendMessage ：在Java端的回调方法中，通过 UnityPlayer.UnitySendMessage("GameObjectName", "MethodName", "parameter") 来调用Unity中某个GameObject上的方法。这种方式更简单直接，但耦合度稍高。 在实际项目中，我推荐第一种方式，结构更清晰。你需要根据 TTSHelper.java 中定义的回调接口，在C#中创建对应的 AndroidJavaProxy 子类。

4.4 适配RT-Voice插件调用

现在，我们有了一个可靠的Android TTS后端( AndroidTTSManager )。接下来，我们需要让RT-Voice使用这个后端，而不是它默认的、可能出问题的系统调用。

思路 ：RT-Voice通常有一个核心的静态类或管理器（例如 RTVoice 或 SpeechManager ）负责播放。我们需要创建一个“适配层”或“包装器”。

1. 创建RT-Voice适配脚本 ：例如 RTVoiceAndroidAdapter.cs 。
2. 在适配脚本中 ：
   • 在 Start() 或 Awake() 中，初始化 AndroidTTSManager.Instance 。
   • 编写一个公共方法，如 PlayAndroidTTS(string text, float rate, float pitch) 。
   • 在这个方法内部，调用 AndroidTTSManager.Instance.Speak(text, ...) ，并将rate（语速）、pitch（音调）参数通过某种方式传递给Android端（可能需要扩展Java接口以支持这些参数）。
   • 关键一步 ：修改你项目中原本调用RT-Voice播放语音的代码。将 RTVoice.Speak(...) 替换为对这个适配器方法 RTVoiceAndroidAdapter.PlayAndroidTTS(...) 的调用。

一个简化的适配器示例 ：

public class RTVoiceAndroidAdapter : MonoBehaviour
{
    public static RTVoiceAndroidAdapter Instance;

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            // 确保Android TTS管理器已初始化
            var mgr = AndroidTTSManager.Instance;
            // 可以在这里调用mgr.InitializeTTS()并等待回调
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public void Speak(string text, float rate = 1.0f, float pitch = 1.0f)
    {
#if UNITY_ANDROID && !UNITY_EDITOR
        // 在安卓真机上使用我们自己的TTS管理器
        string utteranceId = Guid.NewGuid().ToString();
        AndroidTTSManager.Instance.Speak(text, utteranceId,
            (uid) => Debug.Log($"Android TTS started: {uid}"),
            (uid) => Debug.Log($"Android TTS finished: {uid}"),
            (uid, err) => Debug.LogError($"Android TTS error: {uid}, {err}")
        );
#else
        // 在编辑器或其他平台，使用原生的RT-Voice
        // 假设RT-Voice的API是 RTVoice.Speak(text, rate, pitch);
        // 你需要根据RT-Voice的实际API进行调整
        // RTVoice.Speak(text, rate, pitch);
        Debug.Log($"Editor TTS would speak: {text}");
#endif
    }
}

在你的游戏逻辑代码中，将所有的 RTVoice.Speak(...) 调用替换为 RTVoiceAndroidAdapter.Instance.Speak(...) 。

5. 打包、测试与疑难问题排查实录

配置完成后，进行打包测试是验证方案是否可行的最终环节。

5.1 完整打包流程与关键检查点

1. 构建APK ：在Unity中， File -> Build Settings ，确保场景已添加，点击 Build 或 Build And Run 。
2. 安装到设备 ：将生成的APK文件安装到你的安卓测试手机或模拟器上。
3. 首次运行检查 ：
   • 网络连接 ：首次运行，如果设备上没有中文语音数据，我们的代码会触发 ACTION_INSTALL_TTS_DATA 意图，跳转到Google TTS的数据安装界面。 确保设备可以访问网络 （可能需要连接互联网）以下载语音包。这是一个关键点，最好在应用启动时给用户一个友好的提示。
   • 权限请求 ：如果你的AR应用需要相机权限，确保在首次使用相机前已经通过 UnityEngine.Android.Permission.RequestUserPermission 请求并获得了授权，否则AR功能会失败。
   • 日志查看 ：使用 adb logcat 命令或Unity Remote配合Unity Editor的Console窗口，查看TTS初始化和播放的日志，这是排查问题最直接的手段。

5.2 常见问题与解决方案速查表

以下是我在实战中遇到的一些典型问题及解决方法：

5.3 性能优化与进阶技巧

1. 预热与缓存 ：在应用启动后、需要播放语音前，提前初始化 AndroidTTSManager （例如在加载场景时），避免第一次播放时的初始化延迟。对于固定内容的语音，可以考虑使用 synthesizeToFile 合成并保存为音频文件，后续直接播放文件，体验更流畅。
2. 语音队列管理 ：我们的示例使用了 QUEUE_ADD ，这意味着多次调用 speak 会形成队列依次播放。如果需要打断当前播放并立即播放新的内容，可以使用 QUEUE_FLUSH 。你可以根据业务逻辑封装更复杂的队列管理。
3. 多语言支持 ：在 TTSHelper.java 的 onInit 方法中，可以根据需要设置不同的 Locale （如 Locale.US 、 Locale.JAPANESE ）。甚至可以提供接口让C#端动态设置语言。
4. 处理音频焦点 ：在安卓上，当有其他应用（如音乐播放器）播放音频时，你的TTS可能会被中断。可以通过 AudioManager 申请和释放音频焦点，来更好地与其他音频应用协作。

6. 总结与最终建议

通过以上步骤，我们成功地将Unity AR项目中RT-Voice插件在安卓平台无声的问题，定位到了“系统TTS引擎碎片化”这一根源，并提供了通过集成和配置Google TTS服务作为稳定后端的完整解决方案。这个方案的核心优势在于，它利用了Google Play服务广泛覆盖的特性，为应用提供了一个相对统一的、高质量的语音合成环境。

我个人在实际操作中的体会是 ：跨平台插件在移动端，尤其是安卓端出问题，十有八九是 环境差异 和 权限配置 导致的。解决问题的关键不是盲目修改插件代码，而是 深入理解插件在目标平台上的工作原理和依赖 。对于RT-Voice，就是理解它如何桥接到Android的 TextToSpeech API，以及这个API又依赖于什么。

最后再分享一个小技巧 ：在开发类似功能时， 一定要尽早进行真机测试 ，并且最好准备多台不同品牌、不同系统版本的安卓测试机。编辑器里的风平浪静，往往掩盖了真机上的惊涛骇浪。对于TTS这类强系统依赖的功能，在项目初期就完成核心机型的适配，能为后期节省大量的调试时间。

这个方案虽然以RT-Voice为例，但其原理和Android TTS的配置流程，同样适用于任何需要在Unity安卓项目中集成稳定语音合成功能的场景。希望这篇详细的踩坑记录和实战指南，能帮助你顺利绕过这个“坑”，让你的AR应用“畅所欲言”。