离线语音识别demo_语音识别 demo - CSDN
精华内容
参与话题
  • android离线语音识别demo

    千次阅读 2013-11-20 18:45:20
    经过多方查找资料,发现需要装一个Google语音的插件,运行语音识别的时候要用到。如果没有就提示没有找到设备。 下载地址:http://download.csdn.net/detail/wojiao555555/6014985 代码如下: ...

    开始做这个的时候,从网上当了一段代码,但后来测试老是提示没有找到设备。。。非常烦人。。。

    经过多方查找资料,发现需要装一个Google语音的插件,运行语音识别的时候要用到。如果没有就提示没有找到设备。

    下载地址:http://download.csdn.net/detail/wojiao555555/6014985

    代码如下:

    1. public class RecognizerIntentActivity extends Activity {  
    2.   
    3.     private Button btnReconizer;  
    4.     private static final int VOICE_RECOGNITION_REQUEST_CODE = 1234;  
    5.     @Override  
    6.     protected void onCreate(Bundle savedInstanceState) {  
    7.         // TODO Auto-generated method stub  
    8.         super.onCreate(savedInstanceState);  
    9.         setContentView(R.layout.reconizer);  
    10.           
    11.         btnReconizer=(Button) this.findViewById(R.id.btnRecognizer);  
    12.         btnReconizer.setOnClickListener(new OnClickListener() {  
    13.               
    14.             @Override  
    15.             public void onClick(View v) {  
    16.                 // TODO Auto-generated method stub  
    17.                 try{  
    18.                 //通过Intent传递语音识别的模式,开启语音  
    19.                 Intent intent=new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);  
    20.                 //语言模式和自由模式的语音识别  
    21.                 intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);  
    22.                 //提示语音开始  
    23.                 intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "开始语音");  
    24.                 //开始语音识别  
    25.                 startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);  
    26.                 }catch (Exception e) {  
    27.                     // TODO: handle exception  
    28.                     e.printStackTrace();  
    29.                     Toast.makeText(getApplicationContext(), "找不到语音设备"1).show();  
    30.                 }  
    31.             }  
    32.         });  
    33.           
    34.     }  
    35.       
    36.     @Override  
    37.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
    38.         // TODO Auto-generated method stub  
    39.         //回调获取从谷歌得到的数据   
    40.         if(requestCode==VOICE_RECOGNITION_REQUEST_CODE && resultCode==RESULT_OK){  
    41.             //取得语音的字符  
    42.             ArrayList<String> results=data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);  
    43.               
    44.             String resultString="";  
    45.             for(int i=0;i<results.size();i++){  
    46.                 resultString+=results.get(i);  
    47.             }  
    48.             Toast.makeText(this, resultString, 1).show();  
    49.         }  
    50.         super.onActivityResult(requestCode, resultCode, data);  
    51.     }  
    52. }  


    上边的那个需要连网,因为是把语音信号发送到google服务器上进行比对、识别的。所以这次打算弄个离线的demo,就是开着航班模式也能识别的。demo。

    参考如下:

    http://www.cnblogs.com/yin52133/archive/2012/07/12/2588201.html#2611619

    代码可以从这里下载:

    http://download.csdn.net/detail/wojiao555555/6015003


    展开全文
  • 基于科大讯飞语音识别demo离线

    热门讨论 2020-07-30 11:41:16
    基于科大讯飞语音识别demo(离线版的)。源码是从官demo提取出来的,简单明了,项目可以直接运行。依赖讯飞语音的apk和离线语音包(demo中可直接下载)
  • 百度离线语音识别

    万次阅读 2019-01-11 15:56:24
    百度离线语音识别简介百度语音离线识别集成离线识别实现合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    简介

    本文记录百度离线识别与讯飞离线语音识别,针对的是应用本身级别的。

    百度语音离线识别集成

    1. 首先下载开发架包:bdasr_V3_20180801_d6f298a.jar,这个是离在线融合的SDK ;

    2. 导入so库:可在下载的demo中找到,复制到自己工程中同名的路径下
      在这里插入图片描述

    3. 需要百度开放平台上去申请 API Key 和 Secret Key,这是认证权限的必备信息,只有认证通过才可以继续使用语音功能,如语音唤醒,在线识别,离线识别等等。首先需要百度开放平台上去申请 API Key 和 Secret Key,这是认证权限的必备信息,只有认证通过才可以继续使用语音功能,如语音唤醒,在线识别,离线识别等等。
      在这里插入图片描述
      而鉴权认证就是要成功获取到AccessToken(Access Token 是用户身份验证和授权的凭证),而这个认证过程需要自己在应用中编写,之后会提到。
      将获取到的AppID、API Key 和 Secret Key添加到项目的配置文件中去;

    4. AndroidManifest.xml 文件的配置:
      设置权限(如果是Android 6.0 以上还需要获取动态权限,之后会说到)

        <uses-permission android:name="android.permission.RECORD_AUDIO" />
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
        <uses-permission android:name="android.permission.INTERNET" />
        <uses-permission android:name="android.permission.READ_PHONE_STATE" />
        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    

    设置APP_ID, APP_KEY, APP_SECRET

        <meta-data android:name="com.baidu.speech.APP_ID"
            android:value="9788136" />
        <meta-data
            android:name="com.baidu.speech.API_KEY"
            android:value="0GjQNO5H4pGPf9HyA3AmZEbz" />
        <meta-data
            android:name="com.baidu.speech.SECRET_KEY"
            android:value="db981ef3ec647ba8a09b599ad7447a24" />
    
    1. 注意事项:在申请API Key时需要设置应用包名,并且保证官网申请时的与app/bulid.gradle里的applicationId一致,否则会导致离线命令词或是唤醒报“no licenece”的错误。

    离线识别实现

    1.可以先准备本地词库和唤醒词库

    2.基于SDK的使用:

    • 初始化EventManager类
     EventManager  asr = EventManagerFactory.create(context, "asr");//语音识别器
     EventManager  wp = EventManagerFactory.create(context, "wp");//语音唤醒器
    
    • 定义输出事件类
    public class RecogResultManager implements EventListener{
        ...........
        
         /**
         * 回调事件
         */
        @Override
        public void onEvent(String name, String params, byte[] data, int offset, int length) {
            String logMessage = "name:" + name + "; params:" + params;
            Log.d(TAG, logMessage);
            switch (name) {
                case SpeechConstant.CALLBACK_EVENT_ASR_READY:
                    // 引擎准备就绪,可以开始说话              
                    break;
                case SpeechConstant.CALLBACK_EVENT_ASR_BEGIN:
                    // 检测到用户的已经开始说话
                    break;
                case SpeechConstant.CALLBACK_EVENT_ASR_END:
                    // 检测到用户的已经停止说话
                    break;
                case SpeechConstant.CALLBACK_EVENT_ASR_PARTIAL:
                    // 临时识别结果, 长语音模式需要从此消息中取出结果
                    break;
                  case SpeechConstant.CALLBACK_EVENT_ASR_FINISH:
                    // 识别结束, 最终识别结果或可能的错误
                    break;
                case SpeechConstant.CALLBACK_EVENT_ASR_LONG_SPEECH:
                    // 长语音
                    break;
                case SpeechConstant.CALLBACK_EVENT_ASR_VOLUME:
                    //音量值 
                    break;
                case SpeechConstant.CALLBACK_EVENT_ASR_AUDIO:
                    if (data.length != length) {
                     //可能出错的地方:回调返回的数据有问题
                       Log.d(TAG, "internal error: asr.audio" +
                                " callback data length is not equal to length param");
                     .....
                    }
                    break;
                case SpeechConstant.CALLBACK_EVENT_WAKEUP_SUCCESS:
                    //语音唤醒成功 
                    break;
                case SpeechConstant.CALLBACK_EVENT_WAKEUP_ERROR:
                    //语音唤醒失败
                    break;
                .......
    
                default:
                    break;
            }
        }
    }    
    
    
    
    • 注册自己的输出事件类
    asr.registerListener(eventListener);
    wp.registerListener(eventListener);
    
    • 加载唤醒词库与离线词库
     /**
     - 加载唤醒词库
      */
        private void loadWakeup() {
            Map<String, Object> params = new HashMap<>();
            params.put(SpeechConstant.WP_WORDS_FILE, "assets://WakeUp.bin");
            //开始识别语音唤醒
            mWakeup.start(params);
        }
        
     /**
     - 加载离线词库
      */
        private void loadWakeup() {
           Map<String, Object> params = new LinkedHashMap<>();
           //设置此参数使用与语音唤醒后进入语音识别模式
            params.put(SpeechConstant.VAD, SpeechConstant.VAD_DNN);
            params.put(SpeechConstant.DECODER, 2);
            params.put(SpeechConstant.ASR_OFFLINE_ENGINE_GRAMMER_FILE_PATH, "assets://baidu_speech_grammar.bsg");
           //设置唤醒到识别的停顿时间
            if (backTrackInMs > 0) {
                params.put(SpeechConstant.AUDIO_MILLS, System.currentTimeMillis() - backTrackInMs);
            }
            mRecognizer.cancel();
            //开始进行识别
            mRecognizer.start(params);
        }
         注:对于语音唤醒到识别有两种方案:
         方案1: backTrackInMs > 0,唤醒词说完后,直接接句子,中间没有停顿,
                开启回溯,连同唤醒词一起整句识别,推荐4个字 1500ms,backTrackInMs 最大 15000,即15s.
         方案2: backTrackInMs = 0,唤醒词说完后,中间有停顿,不开启回溯。唤醒词识别回调后,正常开启识别。
                官方demo里采用默认设置的是1500,本人demo中选择的是方案2,因为测试结果方案2的识别效果好一些,详见下面测试结果。
    
    • 查询权限,获取AccessToken
    public void check() {
            appendLogMessage("try to check appId " + appId + " ,appKey=" + appKey + " ,secretKey" + secretKey);
            if (appId == null || appId.isEmpty()) {
                  errorMessage = "appId 为空";
                  fixMessage = "填写appID";
              }
            if (appKey == null || appKey.isEmpty()) {
                    errorMessage = "appKey 为空";
                    fixMessage = "填写appID";
              }
            if (secretKey == null || secretKey.isEmpty()) {
                     errorMessage = "secretKey 为空";
                      fixMessage = "secretKey";
             }
            try {
                    checkOnline();
            } catch (UnknownHostException e) {
                    infoMessage = "无网络或者网络不连通,忽略检测 : " + e.getMessage();
            } catch (Exception e) {
                    errorMessage = e.getClass().getCanonicalName() + ":" + e.getMessage();
                    fixMessage = " 重新检测appId, appKey, appSecret是否正确";
             }
     }
    
    /**
     *  获取并校验token
     */
      public void checkOnline() throws Exception {
                String urlpath = "http://openapi.baidu.com/oauth/2.0/token?grant_type=client_credentials&client_id="
                        + appKey + "&client_secret=" + secretKey;
                URL url = new URL(urlpath);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(1000);
                InputStream is = conn.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(is));
                StringBuilder result = new StringBuilder();
                String line = "";
                do {
                    line = reader.readLine();
                    if (line != null) {
                        result.append(line);
                    }
                } while (line != null);
               String res = result.toString();
               if (!res.contains("audio_voice_assistant_get")) {
                    errorMessage = "appid:" + appId + ",没有audio_voice_assistant_get 权限,请在网页上开通\"语音识别\"能力";
                    fixMessage = "secretKey";
                    return;
                }
                appendLogMessage("openapi return " + res);
                JSONObject jsonObject = new JSONObject(res);
                String error = jsonObject.optString("error");
                if (error != null && !error.isEmpty()) {
                    errorMessage = "appkey secretKey 错误" + ", error:" + error + ", json is" + result;
                    fixMessage = " 重新检测appId对应的 appKey, appSecret是否正确";
                    return;
                }
               String token = jsonObject.getString("access_token");
               if (token == null || !token.endsWith("-" + appId)) {
                    errorMessage = "appId 与 appkey及 appSecret 不一致。
                    appId = " + appId + " ,token = " + token;
                    fixMessage = " 重新检测appId对应的 appKey, appSecret是否正确";
                }
            }
        }
    
    • 加载动态权限(Android 6.0以上需要)
      在主Activity中添加:
    
     private void initPermission() {
            String[] permissions = {Manifest.permission.RECORD_AUDIO,
                    Manifest.permission.ACCESS_NETWORK_STATE,
                    Manifest.permission.INTERNET,
                    Manifest.permission.READ_PHONE_STATE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE
            };
            ArrayList<String> toApplyList = new ArrayList<>();
           for (String perm : permissions) {
                if (PackageManager.PERMISSION_GRANTED != ContextCompat.checkSelfPermission(this, perm)) {
                    toApplyList.add(perm);
                    // 进入到这里代表没有权限.
                }
            }
            String[] tmpList = new String[toApplyList.size()];
            if (!toApplyList.isEmpty()) {
                ActivityCompat.requestPermissions(this, toApplyList.toArray(tmpList), 123);
            }
        }
        
    @Override
       public void onRequestPermissionsResult(int requestCode,
                                               @NonNull String[] permissions,
                                               @NonNull int[] grantResults) {
            // 此处为android 6.0以上动态授权的回调,用户自行实现。
        }
    
    • 控制识别/唤醒
       /**
        * 语音唤醒开始
        */
        public void start(Map<String, Object> params) {
            String json = new JSONObject(params).toString();
            wp.send(SpeechConstant.WAKEUP_START, json, null, 0, 0);
        }
        
        /**
         * 停止语音唤醒
         */
        public void stop() {
            wp.send(SpeechConstant.WAKEUP_STOP, null, null, 0, 0);
        }
    
        /**
         * 开始识别
         */
        public void start(Map<String, Object> params) {
            String json = new JSONObject(params).toString();
            asr.send(SpeechConstant.ASR_START, json, null, 0, 0);
        }
        
        /**
         * 提前结束录音等待识别结果。
         */
        public void stop() {
            if (!isInited) {
                throw new RuntimeException("release() was called");
            }
            asr.send(SpeechConstant.ASR_CANCEL, "{}", null, 0, 0);
        }
        
        /**
         * 取消本次识别,取消后将立即停止不会返回识别结果。
         * cancel 与stop的区别是 cancel在stop的基础上,完全停止整个识别流程,
         */
        public void cancel() {
            if (!isInited) {
                throw new RuntimeException("release() was called");
            }
            asr.send(SpeechConstant.ASR_CANCEL, "{}", null, 0, 0);
        }
    
    • 事件管理器退出,回收资源,不能一直占用着mic资源。
        /**
         * 释放语音唤醒资源
         */
        public void release() {
           if (wp== null) {
                return;
            }
            stop();
            wp.unregisterListener(eventListener);
            wp = null;
            isInited = false;
        }
       
        /**
         * 释放语音识别资源
         */
          public void release() {
            if (asr == null) {
                return;
            }
            cancel();
            asr.send(SpeechConstant.ASR_KWS_UNLOAD_ENGINE, null, null, 0, 0);
            asr.unregisterListener(eventListener);
            asr = null;
            isInited = false;
        }
    

    添加动作识别:

    之前考虑是用数据库匹配识别结果,来找到相应的组件,但是demo里做得着急,只是通过管理activity,以activity和name为媒介来找到相应的组件,从而执行相应的动作。

    public abstract class BaseActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            VrApplication.getInstance().addActivity(this);
        }
        @Override
        protected void onDestroy() {
            super.onDestroy();
            VrApplication.getInstance().removeActivity(this);
        }
    }
    
    public class VrApplication extends Application {
    
        private static final VrApplication INSTANCE = new VrApplication();
    
        private  List<BaseActivity> mActivities;
    
        private VrApplication() {}
    
        public static VrApplication getInstance() {
            return VrApplication.INSTANCE;
        }
    
        public  void addActivity(BaseActivity activity){
            if(mActivities == null){
                mActivities = new ArrayList<>();
            }
            mActivities.add(activity);
        }
        
          public  void removeActivity(BaseActivity activity){
            mActivities.remove(activity);
        }
    
        public List<BaseActivity> getActivities() {
            return mActivities;
        }
    
        /**
         * 关闭应用后需要清空管理
         */
         public  void finishAll(){
            for(BaseActivity activity : mActivities){
                if(! activity.isFinishing()){
                    activity.finish();
                }
            }
        }
    }
    

    所有的界面activity需要继承BaseActivity,初始化组件时保存起来,界面销毁时clear()。

     private void initView() {
            mViews = new HashMap<>();
            EditText etCode = (EditText) findViewById(R.id.tv_point_code);
            Button action = (Button) findViewById(R.id.btn_action);
            mViews.put(etCode.getHint().toString(), etCode);
            mViews.put(action.getText().toString(), action);
        }
    

    回调监听处理结果,进行确认组件去执行相应的动作:

    public class RecogResultManager implements EventListener, IStatus {
         ...............
         
        /**
         * 回调事件
         */
        @Override
        public void onEvent(String name, String params, byte[] data, int offset, int length) {
               switch (name) {
                    ........
                    case SpeechConstant.CALLBACK_EVENT_ASR_PARTIAL:
                         // 临时识别结果, 长语音模式需要从此消息中取出结果
                         handlePartial(params, data, offset, length);
                         break;
                    case SpeechConstant.CALLBACK_EVENT_ASR_FINISH:
                         // 识别结束, 最终识别结果或可能的错误
                         handleFinish(params);
                         break;
                    ........
                    case SpeechConstant.CALLBACK_EVENT_WAKEUP_SUCCESS:
                         //语音唤醒成功
                         handleWpSuccess(name, params);
                         break;
                    case SpeechConstant.CALLBACK_EVENT_WAKEUP_ERROR:
                         handleWpErro(name, params);
                         break;
              }
        } 
        ........
    }               
    

    处理语音唤醒,语音唤醒后,要切换开始进行语音识别:

    private void handleWpMsg() {
            Map<String, Object> mParams = new LinkedHashMap<>();
            mParams.put(SpeechConstant.VAD, SpeechConstant.VAD_DNN);
            mParams.put(SpeechConstant.DECODER, 2);
            mParams.put(SpeechConstant.ASR_OFFLINE_ENGINE_GRAMMER_FILE_PATH, BSGPATH);
             if (mBackTrackInMs > 0) {
                mParams.put(SpeechConstant.AUDIO_MILLS, System.currentTimeMillis() - mBackTrackInMs);
            }
            mRecognizer.cancel();
            mRecognizer.start(mParams);
     }
    

    处理语音识别结果:

    private void analysData(RecogResult recogResult) {
            String results = recogResult.getBestResult();
            //从缓存中获取当前的Activity
            BaseActivity activityInstance = UiUtil.getActivityInstance(mContext);
            if (activityInstance == null) {
                return;
            }
            Map<String, View> views = activityInstance.getViews();
            for (Map.Entry<String, View> entry : views.entrySet()) {
                if (results.contains(entry.getKey())) {
                    action(entry.getValue(), results);
                }
            }
      }
    

    执行动作:

     private void action(View value, String results) {
            if (value instanceof Button) {
                value.performClick();
            } else if (value instanceof EditText) {
                ((EditText) value).setText(results);
            }
     }
    

    注意事项

    1.即使只进行离线操作,第一次也需要进行联网进行认证授权才可以进行接下来的语音识别。
    2. 不用时要及时释放,不能一直占用mic资源,影响其他使用。
    3. 环境嘈杂时,识别率会很低,需要依赖降噪算法。
    4.本demo针对一个应用来说,通过语音识别命令,并执行操作,跳转界面,点击操作,选择操作等,有一定的局限性,因为离线时,只能识别词库中的词,所以EditText或是TextView填写值的时候,可能没有用户所说的那个值,目前只是依赖在线识别来控制这块,还有待进一步研究。

    demo下载地址:

    链接: https://download.csdn.net/download/weixin_44328479/10910474.
    Alt

    展开全文
  • 最近项目需要,需要调研几家语音识别离线/在线),语义理解,TTS(在线/离线),离线命令词,甚至百度的UNIT上下文使用等,虽然看的不怎么深入,但是也确实调研的不是,主要有百度,科大讯飞,搜狗,云知声,奇梦者...

           最近项目需要,需要调研几家语音识别(离线/在线),语义理解,TTS(在线/离线),离线命令词,甚至百度的UNIT上下文使用等,虽然看的不怎么深入,但是也确实调研的不是,主要有百度,科大讯飞,搜狗,云知声,奇梦者等几家,还有包括硬件(科大的四麦直线麦克风,五麦环绕麦克风,最后升级的六麦环绕麦克风;奇梦者的四麦环绕麦克风+柱形麦克风阵列等)。也写了很多Demo,每一家的特色都不同。这里就不一一列举了。以后有机会在慢慢写下来,这里就简单给一个百度在线ASR和云知声离线TTS结合的案列,实现一个复读机的功能。

           因为现在比较晚了,我先上代码,后面会补充几点注意事项。

    1,准备工作:

    (1)百度SDK的JAR包bdasr_V3_xxx_xxx.jar与云知声的JAR包usc.jar:

    百度SDK下载

    云知声SDK下载

    (先注册登录,选择服务再下载)

    解压找到工程libs中的对应的jar(不在详说),添加在自己新建的工程的libs目录下,添加为library。

    (2) so文件:同理,在刚刚下载的SDK中找到对应的so文件,然后早项目新建一个jniLibs目录(../src/main/)

    (3)云知声离线TTS需要语音包(发不同音色使用的):使用时,需要先运行自己编写的工程,然后在对应设备的app安装的目录下新建tts文件夹,把下面三个文件放进去:

    backend_female

    backend_lzl

    frontend_model

     

    2,代码环节:

    (1)AndroidManifest.xml:主要就是注意几个权限和百度的APP_ID,API_KEY,SECRET_KEY,这个需要自己创建应用,获取这三个值;这步不在累述。

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="aoto.com.baidurecongdemo">
    
        <!-- begin: baidu speech sdk  权限 -->
        <uses-permission android:name="android.permission.RECORD_AUDIO" />
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
        <uses-permission android:name="android.permission.INTERNET" />
        <uses-permission android:name="android.permission.READ_PHONE_STATE" />
        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    
        <application
            android:allowBackup="true"
            android:icon="@mipmap/talk"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/talk"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
            <activity android:name=".MainActivity">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
    
            <meta-data
                android:name="com.baidu.speech.APP_ID"
                android:value="XXXXXXX" />
            <meta-data
                android:name="com.baidu.speech.API_KEY"
                android:value="XXXXXXXXXXX..." />
            <meta-data
                android:name="com.baidu.speech.SECRET_KEY"
                android:value="XXXXXXXXXXXX...." />
    
            <service
                android:name=".ASRService"
                android:enabled="true"
                android:exported="true">
                <intent-filter>
                    <action android:name="aoto.com.ASRService" />
                </intent-filter>
            </service>
        </application>
    
    </manifest>

     

    (2)ASRService:这里我把百度语音识别写成了服务的形式,并开放了AIDL接口,别的应用可以直接调用即可(里面的方法未完善,学习者可以自行添加和修改)

    package aoto.com.baidurecongdemo;
    
    
    import android.app.Service;
    import android.content.Intent;
    import android.os.IBinder;
    import android.os.Message;
    import android.os.RemoteCallbackList;
    import android.os.RemoteException;
    import android.util.Log;
    import com.baidu.speech.EventListener;
    import com.baidu.speech.EventManager;
    import com.baidu.speech.EventManagerFactory;
    import com.baidu.speech.asr.SpeechConstant;
    import com.unisound.client.SpeechConstants;
    import com.unisound.client.SpeechSynthesizer;
    import com.unisound.client.SpeechSynthesizerListener;
    
    import org.json.JSONObject;
    
    import java.io.File;
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    
    public class ASRService extends Service implements EventListener {
        private EventManager asr;
        public static String result;
        private boolean logTime = true;
        private String language;
        long startTime = 0;
        long endTime = 0;
        private MainActivity mainActivity = new MainActivity();
    
    
        private SpeechSynthesizer mTTSPlayer;
        private final String mFrontendModel= "/sdcard/unisound/tts/frontend_model";
        private final String mBackendModel = "/sdcard/unisound/tts/backend_lzl";
    
        //主动发数据
        final RemoteCallbackList<IRemoteServiceCallback> mCallbacks
                = new RemoteCallbackList<IRemoteServiceCallback>();
        private int mValue = 0;
        private static final int REPORT_MSG = 1;
    
        @Override
        public void onCreate() {
            System.out.println("服务创建了:" + "onCreate");
            asr = EventManagerFactory.create(this, "asr");
            asr.registerListener(this);
            super.onCreate();
            //初始化离线引擎
            initTts();
        }
    
        @Override
        public void onStart(Intent intent, int startId) {
            System.out.println("服务开启了:" + "onStart");
            super.onStart(intent, startId);
        }
    
        /**
         * 测试参数填在这里
         */
        public void start() {
            Map<String, Object> params = new LinkedHashMap<String, Object>();
            String event = null;
            event = SpeechConstant.ASR_START; // 替换成测试的event
            params.put(SpeechConstant.ACCEPT_AUDIO_VOLUME, false);
            //判断调用者传过来的语言类型
            if (MainActivity.languge_id == 1) {
                params.put(SpeechConstant.PID, 1736);
            } else if (MainActivity.languge_id == 2) {
                params.put(SpeechConstant.PID, 1836);
            } else if (MainActivity.languge_id == 3) {
                params.put(SpeechConstant.PID, 1636);
            } else {
                params.put(SpeechConstant.PID, 1536);
            }
            System.out.println("MMMMMMMMMMMMMMMMMMLanguage:" + MainActivity.languge_id);
            // 请先使用如‘在线识别’界面测试和生成识别参数。 params同ActivityRecog类中myRecognizer.start(params);
            String json = null; //可以替换成自己的json
            json = new JSONObject(params).toString(); // 这里可以替换成你需要测试的json
            asr.send(event, json, null, 0, 0);
            printLog("输入参数:" + json);
        }
    
        private void stop() {
            asr.send(SpeechConstant.ASR_STOP, null, null, 0, 0); //
        }
    
        //   EventListener  回调方法
        /**
         * @param name   :当前asr状态
         * @param params :解析结果字符串
         * @author why
         */
        @Override
        public void onEvent(String name, String params, byte[] data, int offset, int length) {
            String logTxt = "name: " + name;
            if (params != null && !params.isEmpty()) {
                logTxt += " ;params :" + params;
                //通过name来确定当前状态,从而获取解析结果显示
                if (name.equals("asr.partial")) {
                    String start = "[";
                    String end = "]";
                    //截取解析json字符串中结果显示
                    result = StringTools.SubStringTwoChar(params, start, end);
                    startTime = System.currentTimeMillis();
                }
            }
    
            if (name.equals("asr.finish")) {
                //识别结束
                if(MainActivity.btn.getText().toString().equals("停止")){
                    if (result.equals("")||result==null){
                        result="没有识别到声音";
                    }
                    MainActivity.btn.setText("开始");
                }
                else{
                    if (result.equals("")||result==null){
                        result="No sound at all";
                    }
                    MainActivity.btn.setText("start");
                }
                MainActivity.txtResult.setText(result);
    
                //TTS语音合成
                mTTSPlayer.playText(result);
    
            }
    
            //会话结束标识,发送广播传数据
            if (name.equals("asr.exit")) {
                mainActivity.test(result);
            }
    
            if (name.equals(SpeechConstant.CALLBACK_EVENT_ASR_PARTIAL)) {
                if (params.contains("\"nlu_result\"")) {
                    if (length > 0 && data.length > 0) {
                        logTxt += ", 语义解析结果:" + new String(data, offset, length);
                    }
                }
            } else if (data != null) {
                logTxt += " ;data length=" + data.length;
            }
            //打印识别日志
            printLog(logTxt);
        }
    
        //打印识别日志实现
        private void printLog(String text) {
            if (logTime) {
                text += "  ;time=" + System.currentTimeMillis();
            }
            text += "\n";
            Log.i(getClass().getName(), text);
        }
    
    
        //返回可调用服务方法的接口
        @Override
        public IBinder onBind(Intent intent) {
            System.out.println("MMMMMMMMMMMMMMMMM" + "服务绑定了!");
            return new MyASRresultAIDL();
        }
    
        //百度语音识别
        class MyASRresultAIDL extends ASRresultAIDL.Stub {
            @Override
            public String getASRResult() throws RemoteException {
                return result;
            }
    
            @Override
            public void callStart() throws RemoteException {
                start();
            }
    
            @Override
            public void callStop() throws RemoteException {
                stop();
            }
        }
    
        //初始化离线语音合成引擎实现
        private void initTts() {
            // 初始化语音合成对象
            //mTTSPlayer = new SpeechSynthesizer(this, Config.appKey, Config.secret);
            mTTSPlayer = new SpeechSynthesizer(this, "", "");
            System.out.println("TTTTTTTTTTTTTTTTTTS:"+mTTSPlayer);
            // 设置本地合成
            mTTSPlayer.setOption(SpeechConstants.TTS_SERVICE_MODE, SpeechConstants.TTS_SERVICE_MODE_LOCAL);
            File _FrontendModelFile = new File(mFrontendModel);
            if (!_FrontendModelFile.exists()) {
                System.out.println("文件:" + mFrontendModel + "不存在,请将assets下相关文件拷贝到SD卡指定目录!");
            }
            File _BackendModelFile = new File(mBackendModel);
            if (!_BackendModelFile.exists()) {
                System.out.println("文件:" + mBackendModel + "不存在,请将assets下相关文件拷贝到SD卡指定目录!");
            }
            // 设置前端模型
            mTTSPlayer.setOption(SpeechConstants.TTS_KEY_FRONTEND_MODEL_PATH, mFrontendModel);
            // 设置后端模型
            mTTSPlayer.setOption(SpeechConstants.TTS_KEY_BACKEND_MODEL_PATH, mBackendModel);
            // 设置回调监听
            mTTSPlayer.setTTSListener(new SpeechSynthesizerListener() {
                @Override
                public void onEvent(int type) {
                    switch (type) {
                        case SpeechConstants.TTS_EVENT_INIT:
                            // 初始化成功回调
                            Log.i("", "回调成功 ");
                            break;
                        case SpeechConstants.TTS_EVENT_SYNTHESIZER_START:
                            // 开始合成回调
                            Log.i("", "开始同步");
                            break;
                        case SpeechConstants.TTS_EVENT_SYNTHESIZER_END:
                            // 合成结束回调
                            Log.i("", "结束同步");
                            break;
                        case SpeechConstants.TTS_EVENT_BUFFER_BEGIN:
                            // 开始缓存回调
                            Log.i("", "开始缓存 ");
                            break;
                        case SpeechConstants.TTS_EVENT_BUFFER_READY:
                            // 缓存完毕回调
                            Log.i("", "准备缓存 ");
                            break;
                        case SpeechConstants.TTS_EVENT_PLAYING_START:
                            // 开始播放回调
                            Log.i("", "播放开始 ");
                            break;
                        case SpeechConstants.TTS_EVENT_PLAYING_END:
                            // 播放完成回调
                            Log.i("", "播放结束 ");
                            break;
                        case SpeechConstants.TTS_EVENT_PAUSE:
                            // 暂停回调
                            Log.i("", "暂停 ");
                            break;
                        case SpeechConstants.TTS_EVENT_RESUME:
                            // 恢复回调
                            //log_i("resume");
                            break;
                        case SpeechConstants.TTS_EVENT_STOP:
                            // 停止回调
                            Log.i("", "停止");
                            break;
                        case SpeechConstants.TTS_EVENT_RELEASE:
                            // 释放资源回调
                            Log.i("", "释放资源");
                            break;
                        default:
                            break;
                    }
    
                }
    
                @Override
                public void onError(int type, String errorMSG) {
                    // 语音合成错误回调
                    Log.e("","Error");
                }
            });
    
            // 初始化合成引擎
            int returnvalue= mTTSPlayer.init("");
            System.out.println("EEEEEEEEEEE:"+"初始化引擎"+returnvalue);
        }
    
    }
    

    (3)StringUtils : ASRService中使用的一个工具类

    package aoto.com.baidurecongdemo;
    
    /**
     * author:why
     * created on: 2018/1/31 15:25
     * description:
     */
    public class StringTools {
    
        //截取固定字符床中指定两个字符或者字符串之间的子字符串
    
        /**
         *
         * @param target :要处理字符串
         * @param start :起始字符串/字符
         * @param end :结束字符串/字符
         * @return
         */
        public static String SubStringTwoChar(String target, String start, String end) {
            int startIndex = target.indexOf(start);
            int endIndex = target.indexOf(end);
            return target.substring(startIndex, endIndex).substring(start.length());
        }
    
    }

    (4)MainActivity:调用服务,演示效果

    package aoto.com.baidurecongdemo;
    
    import android.Manifest;
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.content.pm.PackageManager;
    import android.os.IBinder;
    import android.os.RemoteException;
    import android.support.v4.app.ActivityCompat;
    import android.support.v4.content.ContextCompat;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.View;
    import android.widget.AbsSpinner;
    import android.widget.AdapterView;
    import android.widget.ArrayAdapter;
    import android.widget.Button;
    import android.widget.Spinner;
    import android.widget.TextView;
    
    import com.baidu.speech.asr.SpeechConstant;
    
    /**
     * @author why
     */
    public class MainActivity extends AppCompatActivity implements InterfaceTest{
    
        protected TextView txtLog;
        public static TextView txtResult;
        public static Button btn;
        private String result;
        private static String DESC_TEXT = "在线识别日志";
        public static int languge_id = 0;
        private Intent intent;
        private MyServiceConnection connection;
        private ASRresultAIDL asRresultAIDL;
        private Spinner spinner;
        private String butContext;
    
        /**
         * 测试参数填在这里
         */
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.common_mini);
            initView();
            intent = new Intent(this, ASRService.class);
            connection = new MyServiceConnection();
            bindService(intent, connection, BIND_AUTO_CREATE);
    
        }
    
        //触发语音识别开始与停止
        public void startOrEnd(View view) {
             butContext = btn.getText().toString();
            System.out.println("BBBBBBBBBBBBBBBBBBBBBB"+butContext);
            //先判断选择的语言
            if (butContext.equals("开始") || butContext.equals("start")) {
                //识别结果制空
                try {
                    asRresultAIDL.callStart();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                if (butContext.equals("开始")) {
                    ASRService.result="没有识别到声音";
                    txtResult.setText("请说,我在听");
                    btn.setText("停止");
                } else {
                    ASRService.result="No sound at all";
                    txtResult.setText("Please say,I am listening");
                    btn.setText("stop");
                }
            } else {
                if (butContext.equals("停止")) {
                    btn.setText("开始");
                    try {
                        txtResult.setText("识别结果:" + asRresultAIDL.getASRResult());
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                } else {
                    btn.setText("start");
                    try {
                        txtResult.setText("ASR result:" + asRresultAIDL.getASRResult());
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    asRresultAIDL.callStop();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    
    
        @Override
        protected void onDestroy() {
            unbindService(connection);
            super.onDestroy();
        }
    
        private void initView() {
            txtResult = (TextView) findViewById(R.id.txtResult);
            txtLog = (TextView) findViewById(R.id.txtLog);
            btn = (Button) findViewById(R.id.btn);
            txtLog.setText(DESC_TEXT + "\n");
            spinner = findViewById(R.id.languge_list);
            //下拉框实现
            ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this, R.array.Data, android.R.layout.simple_spinner_item);
            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            spinner.setAdapter(adapter);
            spinner.setPrompt("选择语言");
            //设置下拉框监听
            spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
                @Override
                public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
                    languge_id = position;
                    System.out.println("QQQQQQQQQQQQQQQQQQQQQ"+languge_id);
                    switch (languge_id) {
                        //普通话
                        case 0:
                            txtResult.setText("点击‘开始’");
                            btn.setText("开始");
                            break;
                        //英语
                        case 1:
                            //interfaceBaiduParams.setLanguage("English");
                            txtResult.setText("click 'start'");
                            btn.setText("start");
                            break;
                        // 四川话
                        case 2:
                            //interfaceBaiduParams.setLanguage("SiChuanHua");
                            txtResult.setText("点击‘开始’");
                            btn.setText("开始");
                            break;
                        //粤语
                        case 3:
                            //interfaceBaiduParams.setLanguage("YueYu");
                            txtResult.setText("点击‘开始’");
                            btn.setText("开始");
                            break;
                    }
                }
    
                @Override
                public void onNothingSelected(AdapterView<?> parent) {
    
                }
            });
        }
    
        @Override
        public void test(String str) {
    
        }
    
        private class MyServiceConnection implements ServiceConnection {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    
                asRresultAIDL = ASRresultAIDL.Stub.asInterface(iBinder);
                System.out.println("绑定服务成功了");
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
                System.out.println("解绑服务成功了");
    
            }
        }
    
    }

    (5)ASRresultAIDL.aidl:开放服务里面的方法,供其他应用调用

    // ASRresultAIDL.aidl
    package aoto.com.baidurecongdemo;
    
    // Declare any non-default types here with import statements
    interface ASRresultAIDL {
     String getASRResult();
     void callStart();
     void callStop();
    }

    (6)build.gradle:

    apply plugin: 'com.android.application'
    
    android {
        compileSdkVersion 26
        defaultConfig {
            applicationId "aoto.com.baidurecongdemo"
            minSdkVersion 21
            targetSdkVersion 26
            versionCode 1
            versionName "1.0"
            testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
            //加载对应so文件
            ndk{
                abiFilters 'armeabi'
            }
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
    }
    
    dependencies {
        implementation fileTree(include: ['*.jar'], dir: 'libs')
        implementation 'com.android.support:appcompat-v7:26.1.0'
        implementation 'com.android.support.constraint:constraint-layout:1.0.2'
        testImplementation 'junit:junit:4.12'
        androidTestImplementation 'com.android.support.test:runner:1.0.1'
        androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
        implementation files('libs/bdasr_V3_20171108_9800a2a.jar')
        implementation files('libs/usc.jar')
    
    }

    3,注意事项:

    (1)云知声离线TTSso文件不是X86的,所以window下的x86模拟器是用不了的,但是在window系统下运行arm的模拟器很卡,所以建议真机调试

    (2)我这里在百度语音识别的地方只是实现了最简单的语音识别调用流程,很多的参数没有使用,学习者可以自己完善和添加

    (3)我这里只添加了百度armeabi下的so文件,所以在gradle文件用ndk指定了(ndk已经安装),也可以什么都不加

    (4)我这里主要是实现了一个复读机的功能,你说什么,那边会把识别文本语音合成播放出来,可以自己选择音色

    (5)我这里百度开发了四种语言语音识别

    注:欢迎扫码关注

     

    展开全文
  • 离线语音识别Demo

    2020-07-27 23:30:44
    离线语音识别Demo
  • 博文:https://blog.csdn.net/Crystal_xing/article/details/84957466,Android离线语音识别
  • Android 科大讯飞离线语音识别

    千次阅读 热门讨论 2018-10-19 15:07:05
    最近Boss让我开发一个离线语音听写功能 , 可是我发现科大讯飞的离线版本下架了 , 也看了很多地方如百度语音.......  都没发现有离线版本 , 然而今天突然发现科大讯飞的离线听写又上架了 这就让我很开心 . 我就...

    最近Boss让我开发一个离线语音听写功能 , 可是我发现科大讯飞的离线版本下架了 , 也看了很多地方如百度语音.......

          都没发现有离线版本 , 然而今天突然发现科大讯飞的离线听写又上架了  这就让我很开心 . 我就立马把它下载了下来,集成到我的项目中去 . 然后经过一个小时的努力 , 我把它简单的封装了一下 , 然后很方便的就可以到处调用了 !

          下面我就把我的那个类发上来你们可以直接拷过去用 . 具体有哪些不懂 , 里面传的东西不清楚可以在下方留言 , 我会给你们讲解.

        emmmm~很久没发博客了 , 现在给大家带来些福利 .

    下面就是这个类:

     

    public class LatYuYin {
        private static String TAG = "IatDemo";
        // 语音听写对象
        private SpeechRecognizer mIat;
        // 语音听写UI
        private RecognizerDialog mIatDialog;
    
        // 用HashMap存储听写结果
        private HashMap<String, String> mIatResults = new LinkedHashMap<String, String>();
    
        private Toast mToast;
    
        private Context mContext;
        private SharedPreferences mSharedPreferences;
        private boolean mTranslateEnable = false;
        private EditText mEditText;
    
    
        public LatYuYin(Context context) {
            mContext = context;
            // 初始化识别无UI识别对象
            // 使用SpeechRecognizer对象,可根据回调消息自定义界面;
            mIat = SpeechRecognizer.createRecognizer(mContext, mInitListener);
            // 初始化听写Dialog,如果只使用有UI听写功能,无需创建SpeechRecognizer
            // 使用UI听写功能,请根据sdk文件目录下的notice.txt,放置布局文件和图片资源
            mIatDialog = new RecognizerDialog(mContext, mInitListener);
            mToast = Toast.makeText(context, "", Toast.LENGTH_SHORT);
            mSharedPreferences = mContext.getSharedPreferences(IatSettings.PREFER_NAME, Activity.MODE_PRIVATE);
        }
    
        public void cancelmLat() {
            mIat.cancel();
            showTip("取消听写");
        }
    
        public void stopmLat() {
            mIat.stopListening();
            showTip("停止听写");
        }
    
        int ret = 0;// 函数调用返回值
    
        //开始听写
        public void startmLat(View view) {
            mEditText = (EditText) view.findViewById(R.id.activity_chat_et_text);
            mEditText.setText(null);
            mIatResults.clear();
            // 设置参数
            setParam();
            boolean isShowDialog = mSharedPreferences.getBoolean(mContext.getString(R.string.pref_key_iat_show), true);
            if (isShowDialog) {
                // 显示听写对话框
                mIatDialog.setListener(mRecognizerDialogListener);
                mIatDialog.show();
                showTip(mContext.getString(R.string.text_begin));
            } else {
                // 不显示听写对话框
                ret = mIat.startListening(mRecognizerListener);
                if (ret != ErrorCode.SUCCESS) {
                    showTip("听写失败,错误码:" + ret);
                } else {
                    showTip(mContext.getString(R.string.text_begin));
                }
            }
    
        }
    
        private void showTip(final String str) {
            Toast.makeText(mContext, str, Toast.LENGTH_SHORT).show();
        }
    
        /**
         * 参数设置
         *
         * @return
         */
        public void setParam() {
            // 清空参数
            mIat.setParameter(SpeechConstant.PARAMS, null);
            String lag = mSharedPreferences.getString("iat_language_preference", "mandarin");
            // 设置引擎
            mIat.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
            // 设置返回结果格式
            mIat.setParameter(SpeechConstant.RESULT_TYPE, "json");
    
            this.mTranslateEnable = mSharedPreferences.getBoolean(mContext.getString(R.string.pref_key_translate), false);
            if (mTranslateEnable) {
                Log.i(TAG, "translate enable");
                mIat.setParameter(SpeechConstant.ASR_SCH, "1");
                mIat.setParameter(SpeechConstant.ADD_CAP, "translate");
                mIat.setParameter(SpeechConstant.TRS_SRC, "its");
            }
    
            if (lag.equals("en_us")) {
                // 设置语言
                mIat.setParameter(SpeechConstant.LANGUAGE, "en_us");
                mIat.setParameter(SpeechConstant.ACCENT, null);
    
    
                if (mTranslateEnable) {
                    mIat.setParameter(SpeechConstant.ORI_LANG, "en");
                    mIat.setParameter(SpeechConstant.TRANS_LANG, "cn");
                }
            } else {
                // 设置语言
                mIat.setParameter(SpeechConstant.LANGUAGE, "zh_cn");
                // 设置语言区域
                mIat.setParameter(SpeechConstant.ACCENT, lag);
    
                if (mTranslateEnable) {
                    mIat.setParameter(SpeechConstant.ORI_LANG, "cn");
                    mIat.setParameter(SpeechConstant.TRANS_LANG, "en");
                }
            }
    
            // 设置语音前端点:静音超时时间,即用户多长时间不说话则当做超时处理
            mIat.setParameter(SpeechConstant.VAD_BOS, mSharedPreferences.getString("iat_vadbos_preference", "4000"));
    
            // 设置语音后端点:后端点静音检测时间,即用户停止说话多长时间内即认为不再输入, 自动停止录音
            mIat.setParameter(SpeechConstant.VAD_EOS, mSharedPreferences.getString("iat_vadeos_preference", "1000"));
    
            // 设置标点符号,设置为"0"返回结果无标点,设置为"1"返回结果有标点
            mIat.setParameter(SpeechConstant.ASR_PTT, mSharedPreferences.getString("iat_punc_preference", "1"));
    
            // 设置音频保存路径,保存音频格式支持pcm、wav,设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
            mIat.setParameter(SpeechConstant.AUDIO_FORMAT, "wav");
            mIat.setParameter(SpeechConstant.ASR_AUDIO_PATH, Environment.getExternalStorageDirectory() + "/msc/iat.wav");
            //此处engineType为“local”
            mIat.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_LOCAL);
            if (SpeechConstant.TYPE_LOCAL.equals(SpeechConstant.TYPE_LOCAL)) {
                // 设置本地识别资源
                mIat.setParameter(ResourceUtil.ASR_RES_PATH, getResourcePath());
            }
        }
    
        private String getResourcePath() {
            StringBuffer tempBuffer = new StringBuffer();
            //识别通用资源
            tempBuffer.append(ResourceUtil.generateResourcePath(mContext, ResourceUtil.RESOURCE_TYPE.assets, "iat/common.jet"));
            tempBuffer.append(";");
            tempBuffer.append(ResourceUtil.generateResourcePath(mContext, ResourceUtil.RESOURCE_TYPE.assets, "iat/sms_16k.jet"));
            //识别8k资源-使用8k的时候请解开注释
            return tempBuffer.toString();
        }
    
        /**
         * 初始化监听器。
         */
        private InitListener mInitListener = new InitListener() {
    
            @Override
            public void onInit(int code) {
                Log.d(TAG, "SpeechRecognizer init() code = " + code);
                if (code != ErrorCode.SUCCESS) {
                    showTip("初始化失败,错误码:" + code);
                }
            }
        };
    
        /**
         * 听写UI监听器
         */
        private RecognizerDialogListener mRecognizerDialogListener = new RecognizerDialogListener() {
            public void onResult(RecognizerResult results, boolean isLast) {
                Log.d(TAG, "recognizer result:" + results.getResultString());
                if (mTranslateEnable) {
                    printTransResult(results);
                } else {
                    String text = JsonParser.parseIatResult(results.getResultString());
                    mEditText.append(text);
                    mEditText.setSelection(mEditText.length());
                }
            }
    
    
            /**
             * 识别回调错误.
             */
            public void onError(SpeechError error) {
                if (mTranslateEnable && error.getErrorCode() == 14002) {
                    showTip(error.getPlainDescription(true) + "\n请确认是否已开通翻译功能");
                } else {
                    showTip(error.getPlainDescription(true));
                }
            }
    
        };
        /**
         * 听写监听器。
         */
        private RecognizerListener mRecognizerListener = new RecognizerListener() {
    
            @Override
            public void onBeginOfSpeech() {
                // 此回调表示:sdk内部录音机已经准备好了,用户可以开始语音输入
                showTip("开始说话");
            }
    
            @Override
            public void onError(SpeechError error) {
                // Tips:
                // 错误码:10118(您没有说话),可能是录音机权限被禁,需要提示用户打开应用的录音权限。
                if (mTranslateEnable && error.getErrorCode() == 14002) {
                    showTip(error.getPlainDescription(true) + "\n请确认是否已开通翻译功能");
                } else {
                    showTip(error.getPlainDescription(true));
                }
            }
    
            @Override
            public void onEndOfSpeech() {
                // 此回调表示:检测到了语音的尾端点,已经进入识别过程,不再接受语音输入
                showTip("结束说话");
            }
    
            @Override
            public void onResult(RecognizerResult results, boolean isLast) {
                if (mTranslateEnable) {
                    printTransResult(results);
                } else {
                    String text = JsonParser.parseIatResult(results.getResultString());
                }
    
                if (isLast) {
                    //TODO 最后的结果
                }
            }
    
            @Override
            public void onVolumeChanged(int volume, byte[] data) {
                showTip("当前正在说话,音量大小:" + volume);
                Log.d(TAG, "返回音频数据:" + data.length);
            }
    
            @Override
            public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
                // 以下代码用于获取与云端的会话id,当业务出错时将会话id提供给技术支持人员,可用于查询会话日志,定位出错原因
                // 若使用本地能力,会话id为null
                // if (SpeechEvent.EVENT_SESSION_ID == eventType) {
                //    String sid = obj.getString(SpeechEvent.KEY_EVENT_SESSION_ID);
                //    Log.d(TAG, "session id =" + sid);
                // }
            }
        };
    
        private void printTransResult(RecognizerResult results) {
            String trans = JsonParser.parseTransResult(results.getResultString(), "dst");
            String oris = JsonParser.parseTransResult(results.getResultString(), "src");
    
            if (TextUtils.isEmpty(trans) || TextUtils.isEmpty(oris)) {
                showTip("解析结果失败,请确认是否已开通翻译功能。");
            }
    
        }
    }

    以上就是这个类的代码 , 基本你们拷过去就能用 .  同时你们附加了这两个类你们需要科大讯飞里面的开发包里面拷出来.

    然后具体调用很简单如下:

    以上就是调用的代码简单吧  然后你们不知道还要考哪些东西就把这几个文件都拷进去 , 或者看官方文档

    好了  .........基本就是这些 , 如果还是没成功就在底下留言 , 我看到我会很快的回复你的!

              希望大家工作顺利!!!!!!!

    展开全文
  • 博文配套的源码,初稿,用java调用科大讯飞的离线语音识别dll实现离线识别,只要路径对了,就绝对能运行,跟机型无关,操作系统windows
  • C# 开发的离线语音识别,语音转文字,可以识别短语音,指定识别库,程序已测试运行成功,识别速度快,需要的可以自行修改使用
  • 在跑通Android离线语音识别demo PocketSpinxAndroiDemo后,发现其使用pocketsphinx进行语音识别的准确率并不是很低。这和pocketsphinx语音识别所用的语言模型和声学模型相关。pocketsphinx-0.8源码自带几个语言模型...
  • 语音库及SWIG安装  从http://sourceforge.net/projects/cmusphinx/files/ ,下载sphinxbase-0.8.tar.gz和pocketsphinx-0.8.tar.gz放在同一个目录下,开始安装。 1. 安装sphinxbase  安装, tar -xzf ...
  • Android离线语音识别 PocketSphinx的demo 已封装 即下即用 ! 支持中英两种语言离线识别
  • 关于Android的离线语音识别的技术,遍观若干厂家唯有科大讯飞和百度有离线的语音识别功能,但是科大讯飞是收费的,百度的离线语音识别就是关键词唤醒,但是只接受3个自定义的唤醒词,而且必须经过评定3分以上唤醒词...
  • 首先本文要说的两个前提1.android平台离线语音识别 2.小范围语音 小范围语音指的是相对固定的命令。本文的例子大概实现了20条语音命令,超出范围的无法识别。因此本文中离线语音的使用范围也有限,对于一
  • PocketSphinx For Android离线语音识别

    千次阅读 2018-07-26 11:49:40
    本文将使用PocketSphinx来实现Android平台的离线语音识别优点: 离线,不用联网 识别较准(大家都说99% 我觉得只有80%) 缺点: 自定义语音命令麻烦 只能小范围识别 网上看了很多例子 我跟你说 那都是坑 根本就是错误的...
  • 本项目是做出的产品是一个很大的一个Windows下的增强现实系统,产品功能已经基本完善,考虑到给用户带来更好的体验,故综合评估后采用讯飞语音识别方案进行嫁接。 项目介绍:1)打开系统时启动语音识别,检测到用户...
  • 最近有开发语音识别功能的需求,但是因为各种原因(主要是收费)不能用国内大厂(百度,讯飞)已有的sdk,于是在网上搜了很多android离线语音识别,主要有两种: 1.android自带的SpeechRecognizer,但是试了好几...
  • Android离线语音识别(PocketSphinx)

    千次阅读 2014-10-13 21:56:15
    Android平台下PocketSphinx离线语音识别最完整讲义!
1 2 3 4 5 ... 20
收藏数 1,173
精华内容 469
关键字:

离线语音识别demo