Android 语音语音识别 : Repeated Calling of SpeechRecognizer. startListening() 在 JB 4.1.2 上失败

Question

我有一项服务，我会反复启动语音识别监听器，这样我就可以有一个开放式 session 供用户发言。该类(class)还处理了 Jelly Bean 中的问题，如果 5 秒内没有听到任何语音，则会抛出 ERROR_SPEECH_TIMEOUT。所以基本上这是有效的。但是，如果我重复调用 recognizer.startListening(recognizerIntent) ，它会默默地失败，因为在这种情况下从未调用过 onBeginningOfSpeech() 这一事实。现在，如果我根本不说话，我的 Jelly Bean 超时处理程序将每次都重新启动监听器，而不会失败。它似乎只在调用 onResults() 之后失败，因为听到了语音。调用 onResults() 之后，肯定会调用 recognizer.startListening(recognizerIntent)，但就像我说的，没有任何反应。当它失败时，它是随机的，并且 Logcat 中没有任何内容可以指示问题所在。我只是不知道还能尝试什么。希望你们中的一位 Android 语音识别专家以前见过这个……

最低:2.2目标:在 JB 上测试:Android 4.1.2

---

更多信息 (11-01-13)我的 HTC One 的 4.3 更新肯定解决了这个问题。我下面的语音识别服务现在可靠且准确。我至少运行了几分钟没有错误。至于 4.1.2，在我更新到 4.3 之前，它似乎运行得更好(谷歌最终改变了什么吗？)...我不知道，但它仍然会漏掉一些说出来的词，偶尔也没有错误，只是停止收听(在这种情况下永远不会调用 onBeginningOfSpeech() )。我想我只需要就此问题警告我的用户有关 Android 4.1.2 的信息，因为我已经尽我所能地编写了我的代码。

更多信息 (09-17-13)据推测，HTC 的 Android 更新 (4.3) 将于 9 月底推出 (http://www.ubergizmo.com/2013/09/htc-one-to-receive-android-4-3-jelly-bean-update-this-september/)。所以希望这将解决该设备上的这个问题。对于运行 Android 4.1.2 并在该版本上停留了一段时间的我的应用程序用户来说，问题仍然存在。我仍然不知道在这些情况下该怎么办，希望这是唯一存在此问题的 Android 版本。有没有办法找出有多少设备正在运行 4.1.2？

更多信息 (09-15-13)在这篇文章中:Google voice recognizer doesn't starts on Android 4.x .作者说他在他的 HTC one 上看到了这个问题。我也有一台 HTC，我在 (Android 4.1.2) 上看到了这个问题。我想知道这是不是HTC独有的？ (或任何运行 Android 4.1.2 的设备)- 我无法确认很难在所有运行 JB 的最新设备上进行测试。作者进一步指出，他的 Nexxus 4.2.2 运行良好。谁能告诉我他们在什么设备上看到这个问题？

更多信息 (9-08-13)为了确认我的代码没有问题，我还在 Android 2.3.3 上测试了这个，我能够连续调用 onResult() > startListening() 25 次。当以 Android 4.1.2 为目标时，我永远无法通过 3 或 4 个电话。我不敢相信没有其他人遇到过这个问题？

public class VoiceRecogService extends Service
{
    protected AudioManager mAudioManager; 
    protected SpeechRecognizer mSpeechRecognizer;
    protected Intent mSpeechRecognizerIntent;
    protected RecognitionListener mSpeechRecognizerListner;
    //protected final Messenger mServerMessenger = new Messenger(new IncomingHandler(this));

    protected volatile boolean mIsListening;
    protected volatile boolean mIsCountDownOn;

    static final int MSG_RECOGNIZER_START_LISTENING = 1;
    static final int MSG_RECOGNIZER_CANCEL = 2;

    private int mBindFlag;
    private Messenger mServiceMessenger;

    private Context m_ctx;

    private Handler mHandler = new Handler();
    //private boolean m_bReadyForSpeechReceived = false;

    @Override
    public void onCreate()
    {
        super.onCreate();
        m_ctx = this;

        mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); 

        //do not mute beep when speech listening first kicks off
        Log.d("TESTING: SPEECH SERVICE: CALL START", "onCreate()"); 
        startListening(false);
    }
    private void startListening(boolean bMuteSound){
        Log.d("TESTING: SPEECH SERVICE: startListening()", mIsListening? "true":"false"); 
        if (bMuteSound==true && Build.VERSION.SDK_INT >= 16)//Build.VERSION_CODES.JELLY_BEAN)
        {
            // turn off beep sound  
            mAudioManager.setStreamMute(AudioManager.STREAM_SYSTEM, true);
        }
        if (!mIsListening)
        {
             //mSpeechRecognizer.startListening(mSpeechRecognizerIntent);
             recognizeSpeechDirectly ();
             mIsListening = true;

        }
    }

    /////////////////////////////////////////////////////////////////////////
    /**
     * lazy initialize the speech recognizer
     */
    private SpeechRecognizer getSpeechRecognizer()
    {
        if (mSpeechRecognizer == null)
        {
            mSpeechRecognizer = SpeechRecognizer.createSpeechRecognizer(m_ctx);
        }
        return mSpeechRecognizer;
    }
    private RecognitionListener getSpeechRecognizerListner()
    {
        if (mSpeechRecognizerListner == null)
        {
            mSpeechRecognizerListner = new SpeechRecognitionListener();
        }
        return mSpeechRecognizerListner;
    }

    private void recognizeSpeechDirectly()
    {
        Intent recognizerIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
        recognizerIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
        // accept partial results if they come
        recognizerIntent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);

        recognizeSpeechDirectly(m_ctx,recognizerIntent, getSpeechRecognizerListner(), getSpeechRecognizer());
    }
    public static void recognizeSpeechDirectly(Context context, 
                                               Intent recognizerIntent, 
                                               RecognitionListener listener,
                                               SpeechRecognizer recognizer)
    {
        //need to have a calling package for it to work
        if (!recognizerIntent.hasExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE))
        {
            recognizerIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, "com.dummy");
        }

        recognizer.setRecognitionListener(listener);
        recognizer.startListening(recognizerIntent);
    }
    ////////////////////////////////////////////////////////////////////////////

    public void stop()
    {
        if (getSpeechRecognizer() != null)
        {
            getSpeechRecognizer().stopListening();
            getSpeechRecognizer().cancel();
            getSpeechRecognizer().destroy();

            mIsListening = false;
            if (Build.VERSION.SDK_INT >= 16);//Build.VERSION_CODES.JELLY_BEAN)
                mAudioManager.setStreamMute(AudioManager.STREAM_SYSTEM, false);
        }
    }

    // Count down timer for Jelly Bean work around
    protected CountDownTimer mNoSpeechCountDown = new CountDownTimer(5000, 5000)
    {
        @Override
        public void onTick(long millisUntilFinished)
        {
            // TODO Auto-generated method stub
        }
        @Override
        public void onFinish()
        {
            mIsCountDownOn = false;
            Log.d("TESTING: SPEECH SERVICE: CALL START", "onFinish()"); 
            startListening(true);
        }
    };

    @Override
    public void onDestroy()
    {
        super.onDestroy();

        if (mIsCountDownOn)
        {
            mNoSpeechCountDown.cancel();
        }
        if (mSpeechRecognizer != null)
        {
            mSpeechRecognizer.destroy();
        }
    }

    protected class SpeechRecognitionListener implements RecognitionListener
    {
        @Override
        public void onReadyForSpeech(Bundle params)
        {
            if (Build.VERSION.SDK_INT >= 16)//Build.VERSION_CODES.JELLY_BEAN)
            {
                mIsCountDownOn = true;
                mNoSpeechCountDown.start();
            }
            Log.d("TESTING: SPEECH SERVICE", "onReadyForSpeech"); 
        }
        @Override
        public void onBeginningOfSpeech()
        {
            // speech input will be processed, so there is no need for count down anymore
            if (mIsCountDownOn)
            {
                mIsCountDownOn = false;
                mNoSpeechCountDown.cancel();
            }               
        }
        @Override
        public void onEndOfSpeech()
        {
            Log.d("TESTING: SPEECH SERVICE", "onEndOfSpeech"); 
        }

        @Override
        public void onBufferReceived(byte[] buffer)
        {
            //Log.d("TESTING: SPEECH SERVICE", buffer + new String(new byte[] {0x63})); 
        }

        @Override
        public void onError(int error)
        {
            if ((error == SpeechRecognizer.ERROR_NO_MATCH)
                    || (error == SpeechRecognizer.ERROR_SPEECH_TIMEOUT)){
                if (mIsCountDownOn)
                {
                    mIsCountDownOn = false;
                    mNoSpeechCountDown.cancel();
                }
                 mIsListening = false;
                 Log.d("TESTING: SPEECH SERVICE: CALL START", "onError()"); 
                 startListening(true);
            }
        }

        @Override
        public void onEvent(int eventType, Bundle params)
        {

        }

        @Override
        public void onPartialResults(Bundle partialResults)
        {

        }

        @Override
        public void onResults(Bundle results)
        {
             //String str = new String();
             //Log.d(TAG, "onResults " + results);
             ArrayList data = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);

             //if(data.size() >=1){
             //  //check for save it:
             //}

             for (int i = 0; i < data.size(); i++)
             {
                 Log.d("TESTING: SPEECH SERVICE", (String)data.get(i));
             }

             //if no "save it" somewhere in there, then continue:
             if (mIsCountDownOn)
             {
                 mIsCountDownOn = false;
             }
             mIsListening = false;
             Log.d("TESTING: SPEECH SERVICE: CALL START", "onResults()"); 

             startListening(true);
        }
        @Override
        public void onRmsChanged(float rmsdB)
        {

        }
    }
    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        return null;
    }
}

Answer 1

我在 Nexus 5 上使用 Android 4.4 KitKat，它也有同样的问题。我认为这可能是一个 Android 错误，因为我还没有看到任何人有一个干净的解决方案。
这个解决方案类似于 Andrew_CS 解决方案，但我认为它实际上可以更好地识别。 Andrews 解决方案不断启动和停止识别器，您必须跟踪事物的状态，例如您是否正在处理语音。这个新的解决方案/解决方法基本上是这样做的:

• 调用 onResults 并处理我们的结果后，我们将启动一个计时器。
• 如果一切正常，将调用 onReadyForSpeech，我们可以取消计时器。
• 如果事情没有正常工作，我们的计时器就会结束，我们会重新启动语音识别器并再次启动计时器。
• 确保您也取消了 OnDestroy 方法中的计时器。

如果您找到更好的方法，请告诉我，但目前看来效果还不错。如果我们真的能证明这是一个 Android 错误，我希望有人能将它提交给 Google。

            @Override
        public void onReadyForSpeech(Bundle params) {
            Log.d("Speech", "onReadyForSpeech: Cancel Timer");
            if(mTimer != null) {
                mTimer.cancel();
            }
        }


        @Override
        public void onResults(Bundle results) {
            //If the timer is available, cancel it so it doesn't interrupt our result processing
            if(mTimer != null){
                mTimer.cancel();
            }
            Log.d("Speech", "onResults");
            //Start processing data
            ArrayList<String> strlist = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
            for (int i = 0; i < strlist.size();i++ ) {
                Log.d("Speech", "YOU SAID: " + strlist.get(i));
            }
            //Start listening again
            Log.d("Speech", "onResults: Start Listening");
            mSpeechRecognizer.startListening(mRecognizerIntent);
            //Start a timer in case OnReadyForSpeech is never called back (Android Bug?)
            Log.d("Speech", "onResults: Start a timer");
            if(mTimer == null) {
                mTimer = new CountDownTimer(2000, 500) {
                    @Override
                    public void onTick(long l) {
                    }

                    @Override
                    public void onFinish() {
                        Log.d("Speech", "Timer.onFinish: Timer Finished, Restart recognizer");
                        mSpeechRecognizer.cancel();
                        mSpeechRecognizer.startListening(mRecognizerIntent);
                    }
                };
            }
            mTimer.start();
        }