一区二区视频在线,色桃网,精品三级

鴻蒙AI能力之語音識別

文章旨在幫助大家開發錄音及語音識別時少踩一點坑。

效果

左側為簡易UI布局及識別成果，右側為網易云播放的測試音頻。

開發步驟

IDE安裝、項目創建等在此略過。App采用SDK版本為API 6，使用JS UI。

1.權限申請

AI語音識別不需要任何權限，但此處使用到麥克風錄制音頻，就需要申請麥克風權限。

在config.json配置文件中添加權限：

"reqPermissions": [
{
"name": "ohos.permission.MICROPHONE"
}
]

在MainAbility中顯示申明麥克風權限：

@Override
public void onStart(Intent intent) {
super.onStart(intent);
requestPermission();
}
//獲取權限
private void requestPermission() {
String[] permission = {
"ohos.permission.MICROPHONE",
};
List applyPermissions = new ArrayList<>();
for (String element : permission) {
if (verifySelfPermission(element) != 0) {
if (canRequestPermission(element)) {
applyPermissions.add(element);
}
}
}
requestPermissionsFromUser(applyPermissions.toArray(new String[0]), 0);
}

2.創建音頻錄制的工具類

首先創建音頻錄制的工具類AudioCaptureUtils。

而音頻錄制需要用到AudioCapturer類，而在創建AudioCapture類時又會用到AudioStreamInfo類及AudioCapturerInfo類，所以我們分別申明以上3個類的變量。

private AudioStreamInfo audioStreamInfo;
private AudioCapturer audioCapturer;
private AudioCapturerInfo audioCapturerInfo;

在語音識別時對音頻的錄制是由限制的，限制如下：

所以我們在錄制音頻時需要注意：

1.采樣率16000HZ

2.聲道為單聲道

3.僅支持普通話

作為工具類，為了使AudioCaptureUtils能多處使用，我們在創建構造函數時，提供聲道與頻率的參數重載,并在構造函數中初始化AudioStreamInfo類及AudioCapturerInfo類。

//channelMask 聲道
//SampleRate 頻率
public AudioCaptureUtils(AudioStreamInfo.ChannelMask channelMask, int SampleRate) {
this.audioStreamInfo = new AudioStreamInfo.Builder()
.encodingFormat(AudioStreamInfo.EncodingFormat.ENCODING_PCM_16BIT)
.channelMask(channelMask)
.sampleRate(SampleRate)
.build();
this.audioCapturerInfo = new AudioCapturerInfo.Builder().audioStreamInfo(audioStreamInfo).build();
}

在init函數中進行audioCapturer的初始化，在初始化時對音效進行設置，默認為降噪模式。

//packageName 包名
public void init(String packageName) {
this.init(SoundEffect.SOUND_EFFECT_TYPE_NS,packageName );
}
//soundEffect 音效uuid
//packageName 包名
public void init(UUID soundEffect, String packageName) {
if (audioCapturer == null || audioCapturer.getState() == AudioCapturer.State.STATE_UNINITIALIZED)
audioCapturer = new AudioCapturer(this.audioCapturerInfo);
audioCapturer.addSoundEffect(soundEffect, packageName);
}

初始化后提供start、stop和destory方法，分別開啟音頻錄制、停止音頻錄制和銷毀,此處都是調用AudioCapturer類中對應函數。

public void stop(){
this.audioCapturer.stop();
}
public void destory(){
this.audioCapturer.stop();
this.audioCapturer.release();
}
public Boolean start() {
if (audioCapturer == null)
return false;
return audioCapturer.start();
}

提供一個讀取音頻流的方法及獲取AudioCapturer實例的方法。

//buffers 需要寫入的數據流
//offset 數據流的偏移量
//byteslength 數據流的長度
public int read(byte[] buffers, int offset, int bytesLength){
return audioCapturer.read(buffers,offset,bytesLength);
}
//獲取AudioCapturer的實例audioCapturer
public AudioCapturer get(){
return this.audioCapturer;
}

3.創建語音識別的工具類

在上面我們已經創建好一個音頻錄制的工具類，接下來在創建一個語音識別的工具類 AsrUtils。

我們再回顧一下語音識別的約束與限制：

在此補充一個隱藏限制，PCM流的長度只允許640與1280兩種長度，也就是我們音頻讀取流時只能使用640與1280兩種長度。

接下來我們定義一些基本常量：

//采樣率限定16000HZ
private static final int VIDEO_SAMPLE_RATE = 16000;
//VAD結束時間默認2000ms
private static final int VAD_END_WAIT_MS = 2000;
//VAD起始時間默認4800ms
//這兩參數與識別準確率有關，相關信息可百度查看，在此使用系統默認
private static final int VAD_FRONT_WAIT_MS = 4800;
//輸入時常 20000ms
private static final int TIMEOUT_DURATION = 20000;
//PCM流長度僅限640或1280
private static final int BYTES_LENGTH = 1280;
//線程池相關參數
private static final int CAPACITY = 6;
private static final int ALIVE_TIME = 3;
private static final int POOL_SIZE = 3;

因為要在后臺持續錄制音頻，所以需要開辟一個新的線程。此處用到java的ThreadPoolExecutor類進行線程操作。

定義一個線程池實例以及其它相關屬性如下：

//錄音線程
private ThreadPoolExecutor poolExecutor;
/* 自定義狀態信息
** 錯誤：-1
** 初始：0
** init:1
** 開始輸入:2
** 結束輸入:3
** 識別結束:5
** 中途出識別結果:9
** 最終識別結果：10
*/
public int state = 0;
//識別結果
public String result;
//是否開啟語音識別
//當開啟時才寫入PCM流
boolean isStarted = false;
//ASR客戶端
private AsrClient asrClient;
//ASR監聽對象
private AsrListener listener;
AsrIntent asrIntent;
//音頻錄制工具類
private AudioCaptureUtils audioCaptureUtils;

在構造函數中初始化相關屬性：

public AsrUtils(Context context) {
//實例化一個單聲道，采集頻率16000HZ的音頻錄制工具類實例
this.audioCaptureUtils = new AudioCaptureUtils(AudioStreamInfo.ChannelMask.CHANNEL_IN_MONO, VIDEO_SAMPLE_RATE);
//初始化降噪音效
this.audioCaptureUtils.init("com.panda_coder.liedetector");
//結果值設為空
this.result = "";
//給錄音控件初始化一個新的線程池
poolExecutor = new ThreadPoolExecutor(
POOL_SIZE,
POOL_SIZE,
ALIVE_TIME,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(CAPACITY),
new ThreadPoolExecutor.DiscardOldestPolicy());
if (asrIntent == null) {
asrIntent = new AsrIntent();
//設置音頻來源為PCM流
//此處也可設置為文件
asrIntent.setAudioSourceType(AsrIntent.AsrAudioSrcType.ASR_SRC_TYPE_PCM);
asrIntent.setVadEndWaitMs(VAD_END_WAIT_MS);
asrIntent.setVadFrontWaitMs(VAD_FRONT_WAIT_MS);
asrIntent.setTimeoutThresholdMs(TIMEOUT_DURATION);
}
if (asrClient == null) {
//實例化AsrClient
asrClient = AsrClient.createAsrClient(context).orElse(null);
}
if (listener == null) {
//實例化MyAsrListener
listener = new MyAsrListener();
//初始化AsrClient
this.asrClient.init(asrIntent, listener);
}
}
//夠建一個實現AsrListener接口的類MyAsrListener
class MyAsrListener implements AsrListener {
@Override
public void onInit(PacMap pacMap) {
HiLog.info(TAG, "====== init");
state = 1;
}
@Override
public void onBeginningOfSpeech() {
state = 2;
}
@Override
public void onRmsChanged(float v) {
}
@Override
public void onBufferReceived(byte[] bytes) {
}
@Override
public void onEndOfSpeech() {
state = 3;
}
@Override
public void onError(int i) {
state = -1;
if (i == AsrError.ERROR_SPEECH_TIMEOUT) {
//當超時時重新監聽
asrClient.startListening(asrIntent);
} else {
HiLog.info(TAG, "======error code:" + i);
asrClient.stopListening();
}
}
//注意與onIntermediateResults獲取結果值的區別
//pacMap.getString(AsrResultKey.RESULTS_RECOGNITION);
@Override
public void onResults(PacMap pacMap) {
state = 10;
//獲取最終結果
//{"result":[{"confidence":0,"ori_word":"你好 ","pinyin":"NI3 HAO3 ","word":"你好。"}]}
String results = pacMap.getString(AsrResultKey.RESULTS_RECOGNITION);
ZSONObject zsonObject = ZSONObject.stringToZSON(results);
ZSONObject infoObject;
if (zsonObject.getZSONArray("result").getZSONObject(0) instanceof ZSONObject) {
infoObject = zsonObject.getZSONArray("result").getZSONObject(0);
String resultWord = infoObject.getString("ori_word").replace(" ", "");
result += resultWord;
}
}
//中途識別結果
//pacMap.getString(AsrResultKey.RESULTS_INTERMEDIATE)
@Override
public void onIntermediateResults(PacMap pacMap) {
state = 9;
// String result = pacMap.getString(AsrResultKey.RESULTS_INTERMEDIATE);
// if (result == null)
// return;
// ZSONObject zsonObject = ZSONObject.stringToZSON(result);
// ZSONObject infoObject;
// if (zsonObject.getZSONArray("result").getZSONObject(0) instanceof ZSONObject) {
// infoObject = zsonObject.getZSONArray("result").getZSONObject(0);
// String resultWord = infoObject.getString("ori_word").replace(" ", "");
// HiLog.info(TAG, "=========== 9 " + resultWord);
// }
}
@Override
public void onEnd() {
state = 5;
//當還在錄音時，重新監聽
if (isStarted)
asrClient.startListening(asrIntent);
}
@Override
public void onEvent(int i, PacMap pacMap) {
}
@Override
public void onAudioStart() {
state = 2;
}
@Override
public void onAudioEnd() {
state = 3;
}
}

開啟識別與停止識別的函數：

public void start() {
if (!this.isStarted) {
this.isStarted = true;
asrClient.startListening(asrIntent);
poolExecutor.submit(new AudioCaptureRunnable());
}
}
public void stop() {
this.isStarted = false;
asrClient.stopListening();
audioCaptureUtils.stop();
}
//音頻錄制的線程
private class AudioCaptureRunnable implements Runnable {
@Override
public void run() {
byte[] buffers = new byte[BYTES_LENGTH];
//開啟錄音
audioCaptureUtils.start();
while (isStarted) {
//讀取錄音的PCM流
int ret = audioCaptureUtils.read(buffers, 0, BYTES_LENGTH);
if (ret <= 0) {
HiLog.error(TAG, "======Error read data");
} else {
//將錄音的PCM流寫入到語音識別服務中
//若buffer的長度不為1280或640時，則需要手動處理成1280或640
asrClient.writePcm(buffers, BYTES_LENGTH);
}
}
}
}

識別結果是通過listener的回調獲取的結果，所以我們在處理時是將結果賦值給result，通過getresult或getResultAndClear函數獲取結果。

public String getResult() {
return result;
}
public String getResultAndClear() {
if (this.result == "")
return "";
String results = getResult();
this.result = "";
return results;
}

4.創建一個簡易的JS UI，并通過JS調ServerAbility的能力調用Java

hml代碼：

"container">
"title">
語音識別內容： {{ text }}

樣式代碼：

.container {
flex-direction: column;
justify-content: flex-start;
align-items: center;
width: 100%;
height: 100%;
padding: 10%;
}
.title {
font-size: 20px;
color: #000000;
opacity: 0.9;
text-align: left;
width: 100%;
margin: 3% 0;
}
.btn{
padding: 10px 20px;
margin:3px;
border-radius: 6px;
}

js邏輯控制代碼：

//js調Java ServiceAbility的工具類
import { jsCallJavaAbility } from '../../common/JsCallJavaAbilityUtils.js';
export default {
data: {
text: ""
},
//開啟事件
start() {
jsCallJavaAbility.callAbility("ControllerAbility",100,{}).then(result=>{
console.log(result)
})
},
//關閉事件
stop() {
jsCallJavaAbility.callAbility("ControllerAbility",101,{}).then(result=>{
console.log(result)
})
jsCallJavaAbility.unSubAbility("ControllerAbility",201).then(result=>{
if (result.code == 200) {
console.log("取消訂閱成功");
}
})
},
//訂閱Java端結果事件
sub() {
jsCallJavaAbility.subAbility("ControllerAbility", 200, (data) => {
let text = data.data.text
text && (this.text += text)
}).then(result => {
if (result.code == 200) {
console.log("訂閱成功");
}
})
}
}

ServerAbility：

public class ControllerAbility extends Ability {
AnswerRemote remote = new AnswerRemote();
AsrUtils asrUtils;
//訂閱事件的委托
private static HashMap<Integer, IRemoteObject> remoteObjectHandlers = new HashMap<Integer, IRemoteObject>();
@Override
public void onStart(Intent intent) {
HiLog.error(LABEL_LOG, "ControllerAbility::onStart");
super.onStart(intent);
//初始化語音識別工具類
asrUtils = new AsrUtils(this);
}
@Override
public void onCommand(Intent intent, boolean restart, int startId) {
}
@Override
public IRemoteObject onConnect(Intent intent) {
super.onConnect(intent);
return remote.asObject();
}
class AnswerRemote extends RemoteObject implements IRemoteBroker {
AnswerRemote() {
super("");
}
@Override
public boolean onRemoteRequest(int code, MessageParcel data, MessageParcel reply, MessageOption option) {
Map zsonResult = new HashMap();
String zsonStr = data.readString();
ZSONObject zson = ZSONObject.stringToZSON(zsonStr);
switch (code) {
case 100: {
//當js發送code為100時，開啟語音識別
asrUtils.start();
break;
}
case 101: {
//當js發送code為101時，關閉語音識別
asrUtils.stop();
break;
}
case 200: {
//當js發送code為200時，訂閱獲取識別結果事件
remoteObjectHandlers.put(200 ,data.readRemoteObject());
//定時獲取語音識別結果并返回JS UI
getAsrText();
break;
}
default: {
reply.writeString("service not defined");
return false;
}
}
reply.writeString(ZSONObject.toZSONString(zsonResult));
return true;
}
@Override
public IRemoteObject asObject() {
return this;
}
}
public void getAsrText() {
new Thread(() -> {
while (true) {
try {
Thread.sleep(1 * 500);
Map zsonResult = new HashMap();
zsonResult.put("text",asrUtils.getResultAndClear());
ReportEvent(200, zsonResult);
} catch (RemoteException | InterruptedException e) {
break;
}
}
}).start();
}
private void ReportEvent(int remoteHandler, Object backData) throws RemoteException {
MessageParcel data = MessageParcel.obtain();
MessageParcel reply = MessageParcel.obtain();
MessageOption option = new MessageOption();
data.writeString(ZSONObject.toZSONString(backData));
IRemoteObject remoteObject = remoteObjectHandlers.get(remoteHandler);
remoteObject.sendRequest(100, data, reply, option);
reply.reclaim();
data.reclaim();
}
}