0
0

Android App开发语音处理之系统自带的语音引擎、文字转语音、语音识别的讲解及实战（超详细 附源码）

需要源码请点赞关注收藏后评论区留下QQ~~~

一、系统自带的语音引擎

语音播报的本质是将书面文字转换成自然语言的音频流，这个转换操作被称作语音合成，又称TTS（从文本到语音）在转换过程中，为了避免机械合成的呆板和停顿感，语音合成技术还得对语音流进行平滑处理，以确保输出得语音音律流畅自然。

不管是Android原生的西文引擎还是手机厂商集成的中文引擎，都支持通过系统提供的API处理语音，其中的语音合成工具是TextToSpeech 常用方法如下

构造方法：第二个输入参数为语音监听器

setLanguage：设置引擎语言

setSpeechRate 设置语速

setPitch 设置音调

synthesizeToFile 把指定文本的朗读语言输出到文件

实战效果如下

代码如下

Java类

  1. package com.example.voice;
  3. import android.content.Intent;
  4. import android.os.Bundle;
  5. import android.speech.tts.TextToSpeech;
  6. import android.view.View;
  7. import android.widget.AdapterView;
  8. import android.widget.ArrayAdapter;
  9. import android.widget.ListView;
  10. import android.widget.Spinner;
  12. import androidx.appcompat.app.AppCompatActivity;
  14. import com.example.voice.adapter.LanguageListAdapter;
  15. import com.example.voice.bean.Language;
  17. import java.util.ArrayList;
  18. import java.util.List;
  19. import java.util.Locale;
  21. public class SpeechEngineActivity extends AppCompatActivity {
  22.     private final static String TAG = "SpeechEngineActivity";
  23.     private TextToSpeech mSpeech; // 声明一个文字转语音对象
  25.     @Override
  26.     protected void onCreate(Bundle savedInstanceState) {
  27.         super.onCreate(savedInstanceState);
  28.         setContentView(R.layout.activity_speech_engine);
  29.         findViewById(R.id.btn_jump_setting).setOnClickListener(v -> {
  30.             Intent intent = new Intent();
  31.             intent.setAction("com.android.settings.TTS_SETTINGS");
  32.             startActivity(intent);
  33.         });
  34.         // 创建一个文字转语音对象，初始化结果在监听器TTSListener中返回
  35.         mSpeech = new TextToSpeech(this, new TTSListener());
  36.     }
  38.     private List<TextToSpeech.EngineInfo> mEngineList; // 语音引擎列表
  39.     // 定义一个文字转语音的初始化监听器
  40.     private class TTSListener implements TextToSpeech.OnInitListener {
  41.         // 在初始化完成时触发
  42.         @Override
  43.         public void onInit(int status) {
  44.             if (status == TextToSpeech.SUCCESS) { // 初始化成功
  45.                 if (mEngineList == null) { // 首次初始化
  46.                     // 获取系统支持的所有语音引擎
  47.                     mEngineList = mSpeech.getEngines();
  48.                     initEngineSpinner(); // 初始化语音引擎下拉框
  49.                 }
  50.                 initLanguageList(); // 初始化语言列表
  51.             }
  52.         }
  53.     }
  55.     // 初始化语音引擎下拉框
  56.     private void initEngineSpinner() {
  57.         String[] engineArray = new String[mEngineList.size()];
  58.         for(int i=0; i<mEngineList.size(); i++) {
  59.             engineArray[i] = mEngineList.get(i).label;
  60.         }
  61.         ArrayAdapter<String> engineAdapter = new ArrayAdapter<>(this,
  62.                 R.layout.item_select, engineArray);
  63.         Spinner sp_engine = findViewById(R.id.sp_engine);
  64.         sp_engine.setPrompt("请选择语音引擎");
  65.         sp_engine.setAdapter(engineAdapter);
  66.         sp_engine.setOnItemSelectedListener(new EngineSelectedListener());
  67.         sp_engine.setSelection(0);
  68.     }
  70.     private class EngineSelectedListener implements AdapterView.OnItemSelectedListener {
  71.         public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
  72.             //recycleSpeech(); // 回收文字转语音对象
  73.             // 创建指定语音引擎的文字转语音对象
  74.             mSpeech = new TextToSpeech(SpeechEngineActivity.this, new TTSListener(),
  75.                     mEngineList.get(arg2).name);
  76.         }
  78.         public void onNothingSelected(AdapterView<?> arg0) {}
  79.     }
  81.     private String[] mLanguageArray = {"中文普通话", "英语", "法语", "德语", "意大利语",  };
  82.     private Locale[] mLocaleArray = { Locale.CHINA, Locale.ENGLISH, Locale.FRENCH, Locale.GERMAN, Locale.ITALIAN };
  84.     // 初始化语言列表
  85.     private void initLanguageList() {
  86.         List<Language> languageList = new ArrayList<>();
  87.         // 下面遍历语言数组，从中挑选出当前引擎所支持的语言列表
  88.         for (int i=0; i<mLanguageArray.length; i++) {
  89.             String desc = "正常使用";
  90.             // 设置朗读语言
  91.             int result = mSpeech.setLanguage(mLocaleArray[i]);
  92.             if (result == TextToSpeech.LANG_MISSING_DATA) {
  93.                 desc = "缺少数据";
  94.             } else if (result == TextToSpeech.LANG_NOT_SUPPORTED) {
  95.                 desc = "暂不支持";
  96.             }
  97.             languageList.add(new Language(mLanguageArray[i], desc));
  98.         }
  99.         // 下面把该引擎对各语言的支持情况展示到列表视图上
  100.         ListView lv_language = findViewById(R.id.lv_language);
  101.         LanguageListAdapter adapter = new LanguageListAdapter(this, languageList);
  102.         lv_language.setAdapter(adapter);
  103.     }
  105. }

二、文字转语音

既然明确了一个引擎能够支持哪些语言，接下来就可以大胆设置朗读的语言了，并且设置好语言后，还得提供对应的文字才可以，下面是一个语音播报页面的实例

中文普通话播报

英文版播报

可以在下拉框中选择自己想要朗读的语言

代码如下

Java类

  1. package com.example.voice;
  3. import android.os.Bundle;
  4. import android.speech.tts.TextToSpeech;
  5. import android.util.Log;
  6. import android.view.View;
  7. import android.widget.AdapterView;
  8. import android.widget.ArrayAdapter;
  9. import android.widget.EditText;
  10. import android.widget.Spinner;
  11. import android.widget.Toast;
  13. import androidx.appcompat.app.AppCompatActivity;
  15. import com.example.voice.bean.Language;
  17. import java.util.ArrayList;
  18. import java.util.List;
  19. import java.util.Locale;
  21. public class SpeechComposeActivity extends AppCompatActivity {
  22.     private final static String TAG = "SpeechComposeActivity";
  23.     private TextToSpeech mSpeech; // 声明一个文字转语音对象
  24.     private EditText et_tts; // 声明一个编辑框对象
  25.     private List<TextToSpeech.EngineInfo> mEngineList; // 语音引擎列表
  27.     @Override
  28.     protected void onCreate(Bundle savedInstanceState) {
  29.         super.onCreate(savedInstanceState);
  30.         setContentView(R.layout.activity_speech_compose);
  31.         et_tts = findViewById(R.id.et_tts);
  32.         findViewById(R.id.btn_read).setOnClickListener(v -> {
  33.             String content = et_tts.getText().toString();
  34.             // 开始朗读指定文本
  35.             int result = mSpeech.speak(content, TextToSpeech.QUEUE_FLUSH, null, null);
  36.             String desc = String.format("朗读%s", result==TextToSpeech.SUCCESS?"成功":"失败");
  37.             Toast.makeText(this, desc, Toast.LENGTH_SHORT).show();
  38.         });
  39.         // 创建一个文字转语音对象，初始化结果在监听器的onInit方法中返回
  40.         mSpeech = new TextToSpeech(this, mListener);
  41.     }
  43.     // 创建一个文字转语音的初始化监听器实例
  44.     private TextToSpeech.OnInitListener mListener = status -> {
  45.         if (status == TextToSpeech.SUCCESS) { // 初始化成功
  46.             if (mEngineList == null) { // 首次初始化
  47.                 mEngineList = mSpeech.getEngines(); // 获取系统支持的所有语音引擎
  48.                 initEngineSpinner(); // 初始化语音引擎下拉框
  49.             }
  50.             initLanguageSpinner(); // 初始化语言下拉框
  51.         }
  52.     };
  54.     // 初始化语音引擎下拉框
  55.     private void initEngineSpinner() {
  56.         String[] engineArray = new String[mEngineList.size()];
  57.         for(int i=0; i<mEngineList.size(); i++) {
  58.             engineArray[i] = mEngineList.get(i).label;
  59.         }
  60.         ArrayAdapter<String> engineAdapter = new ArrayAdapter<>(this,
  61.                 R.layout.item_select, engineArray);
  62.         Spinner sp_engine = findViewById(R.id.sp_engine);
  63.         sp_engine.setPrompt("请选择语音引擎");
  64.         sp_engine.setAdapter(engineAdapter);
  65.         sp_engine.setOnItemSelectedListener(new EngineSelectedListener());
  66.         sp_engine.setSelection(0);
  67.     }
  69.     private class EngineSelectedListener implements AdapterView.OnItemSelectedListener {
  70.         public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
  71.             recycleSpeech(); // 回收文字转语音对象
  72.             // 创建指定语音引擎的文字转语音对象
  73.             mSpeech = new TextToSpeech(SpeechComposeActivity.this, mListener,
  74.                     mEngineList.get(arg2).name);
  75.         }
  77.         public void onNothingSelected(AdapterView<?> arg0) {}
  78.     }
  80.     // 回收文字转语音对象
  81.     private void recycleSpeech() {
  82.         if (mSpeech != null) {
  83.             mSpeech.stop(); // 停止文字转语音
  84.             mSpeech.shutdown(); // 关闭文字转语音
  85.             mSpeech = null;
  86.         }
  87.     }
  89.     @Override
  90.     protected void onDestroy() {
  91.         super.onDestroy();
  92.         recycleSpeech(); // 回收文字转语音对象
  93.     }
  95.     private String[] mLanguageArray = {"中文普通话", "英语", "法语", "德语", "意大利语"};
  96.     private Locale[] mLocaleArray = { Locale.CHINA, Locale.ENGLISH, Locale.FRENCH, Locale.GERMAN, Locale.ITALIAN };
  97.     private String[] mValidLanguageArray; // 当前引擎支持的语言名称数组
  98.     private Locale[] mValidLocaleArray; // 当前引擎支持的语言类型数组
  99.     private String mTextCN = "离离原上草，一岁一枯荣。野火烧不尽，春风吹又生。";
  100.     private String mTextEN = "Hello World. Nice to meet you. This is a TTS demo.";
  102.     // 初始化语言下拉框
  103.     private void initLanguageSpinner() {
  104.         List<Language> languageList = new ArrayList<>();
  105.         // 下面遍历语言数组，从中挑选出当前引擎所支持的语言列表
  106.         for (int i=0; i<mLanguageArray.length; i++) {
  107.             // 设置朗读语言。通过检查方法的返回值，判断引擎是否支持该语言
  108.             int result = mSpeech.setLanguage(mLocaleArray[i]);
  109.             Log.d(TAG, "language="+mLanguageArray[i]+",result="+result);
  110.             if (result != TextToSpeech.LANG_MISSING_DATA
  111.                     && result != TextToSpeech.LANG_NOT_SUPPORTED) { // 语言可用
  112.                 languageList.add(new Language(mLanguageArray[i], mLocaleArray[i]));
  113.             }
  114.         }
  115.         mValidLanguageArray = new String[languageList.size()];
  116.         mValidLocaleArray = new Locale[languageList.size()];
  117.         for(int i=0; i<languageList.size(); i++) {
  118.             mValidLanguageArray[i] = languageList.get(i).name;
  119.             mValidLocaleArray[i] = languageList.get(i).locale;
  120.         }
  121.         // 下面初始化语言下拉框
  122.         ArrayAdapter<String> languageAdapter = new ArrayAdapter<>(this,
  123.                 R.layout.item_select, mValidLanguageArray);
  124.         Spinner sp_language = findViewById(R.id.sp_language);
  125.         sp_language.setPrompt("请选择朗读语言");
  126.         sp_language.setAdapter(languageAdapter);
  127.         sp_language.setOnItemSelectedListener(new LanguageSelectedListener());
  128.         sp_language.setSelection(0);
  129.     }
  131.     private class LanguageSelectedListener implements AdapterView.OnItemSelectedListener {
  132.         public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
  133.             if (mValidLocaleArray[arg2]==Locale.CHINA) { // 汉语
  134.                 et_tts.setText(mTextCN);
  135.             } else { // 其他语言
  136.                 et_tts.setText(mTextEN);
  137.             }
  138.             mSpeech.setLanguage(mValidLocaleArray[arg2]); // 设置选中的朗读语言
  139.         }
  141.         public void onNothingSelected(AdapterView<?> arg0) {}
  142.     }
  144. }

三、原生的语音识别

Android提供了语音识别器SpeechRecognizer 该工具常用方法如下

isRecognitionAvailable 检查系统是否支持原生的语音识别

createSpeechRecognizer 创建原生的语音识别器对象

setRecognitionListener 设置语音识别监听器

startListening 开始语音识别

stopListening 停止语音识别

cancel 取消语音识别

destroy 销毁语音识别器

识别结果监听器提供了许多回调方法，其中onResults方法可获得识别后的文本信息，然而每个引擎对文本结果的包装结构不尽相同，比如百度语音返回JSON格式的字符串，而讯飞语音返回字符串列表，为此要分别尝试几种格式的文本识别 效果如下

结果如下 点击开始识别后对着麦克风说话 停止识别后则会自动输出识别内容

此处连接真机测试更佳 模拟机可能没有麦克风~~~

代码如下

java类

  1. package com.example.voice;
  3. import androidx.appcompat.app.AppCompatActivity;
  5. import android.annotation.SuppressLint;
  6. import android.content.ComponentName;
  7. import android.content.Intent;
  8. import android.graphics.Color;
  9. import android.os.Bundle;
  10. import android.provider.Settings;
  11. import android.speech.RecognitionListener;
  12. import android.speech.RecognizerIntent;
  13. import android.speech.SpeechRecognizer;
  14. import android.util.Log;
  15. import android.widget.Button;
  16. import android.widget.TextView;
  18. import org.json.JSONArray;
  19. import org.json.JSONObject;
  21. import java.util.List;
  22. import java.util.Locale;
  24. @SuppressLint("SetTextI18n")
  25. public class SpeechRecognizeActivity extends AppCompatActivity implements RecognitionListener {
  26.     private final static String TAG = "SpeechRecognizeActivity";
  27.     private TextView tv_result; // 声明一个文本视图对象
  28.     private Button btn_recognize; // 声明一个按钮对象
  29.     private SpeechRecognizer mRecognizer; // 声明一个语音识别对象
  30.     private boolean isRecognizing = false; // 是否正在识别
  32.     @Override
  33.     protected void onCreate(Bundle savedInstanceState) {
  34.         super.onCreate(savedInstanceState);
  35.         setContentView(R.layout.activity_speech_recognize);
  36.         tv_result = findViewById(R.id.tv_result);
  37.         btn_recognize = findViewById(R.id.btn_recognize);
  38.         // 检查系统是否支持原生的语音识别
  39.         boolean enable = SpeechRecognizer.isRecognitionAvailable(this);
  40.         if (enable) {
  41.             initRecognize(); // 初始化语音识别
  42.         } else {
  43.             tv_result.setText("原生的语音识别服务不可用");
  44.             btn_recognize.setEnabled(false);
  45.             btn_recognize.setTextColor(Color.GRAY);
  46.         }
  47.     }
  49.     // 初始化语音识别
  50.     private void initRecognize() {
  51.         String serviceComponent = Settings.Secure.getString(
  52.                 getContentResolver(), "voice_recognition_service");
  53.         // 获得系统内置的语音识别服务
  54.         ComponentName component = ComponentName.unflattenFromString(serviceComponent);
  55.         Log.d(TAG, "getPackageName="+component.getPackageName()+",getClassName="+component.getClassName());
  56.         tv_result.setText("原生的语音识别服务采用"+component.getPackageName()
  57.                 +"里的服务"+component.getClassName());
  58.         // 创建原生的语音识别器对象
  59.         mRecognizer = SpeechRecognizer.createSpeechRecognizer(this);
  60.         mRecognizer.setRecognitionListener(this); // 设置语音识别监听器
  61.         btn_recognize.setOnClickListener(v -> {
  62.             if (!isRecognizing) { // 未在识别
  63.                 Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
  64.                 intent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
  65.                 intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.CHINA);
  66.                 intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
  67.                         RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
  68.                 intent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 5);
  69.                 mRecognizer.startListening(intent); // 开始语音识别
  70.             } else { // 正在识别
  71.                 mRecognizer.stopListening(); // 停止语音识别
  72.                 //mRecognizer.cancel(); // 取消语音识别
  73.             }
  74.             isRecognizing = !isRecognizing;
  75.             btn_recognize.setText(isRecognizing?"停止识别":"开始识别");
  76.         });
  77.     }
  79.     @Override
  80.     public void onReadyForSpeech(Bundle params) {}
  82.     @Override
  83.     public void onBeginningOfSpeech() {}
  85.     @Override
  86.     public void onRmsChanged(float rmsdB) {}
  88.     @Override
  89.     public void onBufferReceived(byte[] buffer) {}
  91.     @Override
  92.     public void onEndOfSpeech() {}
  94.     @Override
  95.     public void onError(int error) {
  96.         Log.d(TAG, "Recognize error:"+error);
  97.     }
  99.     @Override
  100.     public void onResults(Bundle results) {
  101.         Log.d(TAG, "onResults Start");
  102.         String desc = "";
  103.         String key = SpeechRecognizer.RESULTS_RECOGNITION;
  104.         try { // 百度语音分支
  105.             String result = results.getString(key);
  106.             Log.d(TAG, "result="+result);
  107.             JSONObject object = new JSONObject(result);
  108.             String recognizeResult = object.getString("recognizeResult");
  109.             JSONArray recognizeArray = new JSONArray(recognizeResult);
  110.             for (int i=0; i<recognizeArray.length(); i++) {
  111.                 JSONObject item = (JSONObject) recognizeArray.get(i);
  112.                 String se_query = item.getString("se_query");
  113.                 desc = desc + "\n" + se_query;
  114.                 Log.d(TAG, "desc="+desc);
  115.             }
  116.         } catch (Exception e) { // 讯飞语音分支
  117.             e.printStackTrace();
  118.             List<String> resultList = results.getStringArrayList(key);
  119.             for (String str : resultList) {
  120.                 desc = desc + "\n" + str;
  121.                 Log.d(TAG, "desc="+desc);
  122.             }
  123.         }
  124.         tv_result.setText("识别到的文字为："+desc);
  125.         Log.d(TAG, "onResults End");
  126.     }
  128.     @Override
  129.     public void onPartialResults(Bundle partialResults) {
  130.         Log.d(TAG, "onPartialResults");
  131.     }
  133.     @Override
  134.     public void onEvent(int eventType, Bundle params) {}
  136.     @Override
  137.     protected void onDestroy() {
  138.         super.onDestroy();
  139.         if (mRecognizer != null) {
  140.             mRecognizer.destroy(); // 销毁语音识别器
  141.         }
  142.     }
  144. }

创作不易 觉得有帮助请点赞关注收藏~~~

标签： 语音识别 人工智能 android
本文转载自: https://blog.csdn.net/jiebaoshayebuhui/article/details/128061083
版权归原作者 showswoller 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Android App开发语音处理之系统自带的语音引擎、文字转语音、语音识别的讲解及实战（超详细 附源码）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？