Android语音识别在3次后停止

首先对不起我的英语，我的母语是西班牙语

我遵循本主题，通过服务和服务在后台实现语音识别

在我的代码中，一切都正常，但当我分别说3个单词时，服务不会听更多的单词或命令

马车来了

11-26 15:51:33.627: D/Icaro(29990): Servicio Voz segundo plano Apagado
11-26 15:51:36.927: D/Icaro(29990): Servicio Voz segundo plano Encendido
11-26 15:51:36.967: D/Icaro(29990): message start listening
11-26 15:51:38.207: D/Icaro(29990): onBeginingOfSpeech
11-26 15:51:39.547: D/Icaro(29990): google   --> command
11-26 15:51:39.547: D/Icaro(29990): onResults
11-26 15:51:39.547: D/Icaro(29990): message start listening
11-26 15:51:40.197: D/Icaro(29990): onBeginingOfSpeech
11-26 15:51:42.187: D/Icaro(29990): facebook  --> command
11-26 15:51:42.187: D/Icaro(29990): onResults
11-26 15:51:42.187: D/Icaro(29990): message start listening
11-26 15:51:43.197: D/Icaro(29990): onBeginingOfSpeech
11-26 15:51:44.947: D/Icaro(29990): whatsapp   --> command 
11-26 15:51:44.947: D/Icaro(29990): onResults
11-26 15:51:44.947: D/Icaro(29990): message start listening
11-26 15:51:46.787: D/Icaro(29990): onBeginingOfSpeech
11-26 15:51:48.057: D/Icaro(29990): google   --> command
11-26 15:51:48.057: D/Icaro(29990): onResults
11-26 15:51:48.067: D/Icaro(29990): message start listening

服务代码在这里

public class SpeechActivationService extends Service
    {
protected AudioManager mAudioManager; 
protected SpeechRecognizer mSpeechRecognizer;
protected Intent mSpeechRecognizerIntent;
protected final Messenger mServerMessenger = new Messenger(new IncomingHandler(this));
protected boolean mIsListening;
protected volatile boolean mIsCountDownOn;

static String TAG = "Icaro";

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

private int mBindFlag;
private Messenger mServiceMessenger;

@Override
public void onCreate()
{
    super.onCreate();
    mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); 
    mSpeechRecognizer = SpeechRecognizer.createSpeechRecognizer(this);
    mSpeechRecognizer.setRecognitionListener(new SpeechRecognitionListener());
    mSpeechRecognizerIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    mSpeechRecognizerIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                                     RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    mSpeechRecognizerIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE,
                                     this.getPackageName());

    //mSpeechRecognizer.startListening(mSpeechRecognizerIntent);
}

protected static class IncomingHandler extends Handler
{
    private WeakReference<SpeechActivationService> mtarget;

    IncomingHandler(SpeechActivationService target)
    {
        mtarget = new WeakReference<SpeechActivationService>(target);
    }


    @Override
    public void handleMessage(Message msg)
    {
        final SpeechActivationService target = mtarget.get();

        switch (msg.what)
        {
            case MSG_RECOGNIZER_START_LISTENING:

                if (Build.VERSION.SDK_INT >= 16);//Build.VERSION_CODES.JELLY_BEAN)
                {
                    // turn off beep sound  
                    target.mAudioManager.setStreamMute(AudioManager.STREAM_SYSTEM, true);
                }
                 if (!target.mIsListening)
                 {
                     target.mSpeechRecognizer.startListening(target.mSpeechRecognizerIntent);
                     target.mIsListening = true;
                    Log.d(TAG, "message start listening"); //$NON-NLS-1$
                 }
                 break;

             case MSG_RECOGNIZER_CANCEL:
                  target.mSpeechRecognizer.cancel();
                  target.mIsListening = false;
                  Log.d(TAG, "message canceled recognizer"); //$NON-NLS-1$
                  break;
         }
   } 
} 

// 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;
        Message message = Message.obtain(null, MSG_RECOGNIZER_CANCEL);
        try
        {
            mServerMessenger.send(message);
            message = Message.obtain(null, MSG_RECOGNIZER_START_LISTENING);
            mServerMessenger.send(message);
        }
        catch (RemoteException e)
        {

        }
    }
};

@Override
public int onStartCommand (Intent intent, int flags, int startId) 
{
    //mSpeechRecognizer.startListening(mSpeechRecognizerIntent);
    try
    {
        Message msg = new Message();
        msg.what = MSG_RECOGNIZER_START_LISTENING; 
        mServerMessenger.send(msg);
    }
    catch (RemoteException e)
    {

    }
    return  START_NOT_STICKY;
}

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

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

protected class SpeechRecognitionListener implements RecognitionListener
{

    @Override
    public void onBeginningOfSpeech()
    {
        // speech input will be processed, so there is no need for count down anymore
        if (mIsCountDownOn)
        {
            mIsCountDownOn = false;
            mNoSpeechCountDown.cancel();
        }               
        Log.d(TAG, "onBeginingOfSpeech"); //$NON-NLS-1$
    }

    @Override
    public void onBufferReceived(byte[] buffer)
    {
        String sTest = "";
    }

    @Override
    public void onEndOfSpeech()
    {
        Log.d("TESTING: SPEECH SERVICE", "onEndOfSpeech"); //$NON-NLS-1$
     }

    @Override
    public void onError(int error)
    {
        if (mIsCountDownOn)
        {
            mIsCountDownOn = false;
            mNoSpeechCountDown.cancel();
        }
         Message message = Message.obtain(null, MSG_RECOGNIZER_START_LISTENING);
         try
         {
             mIsListening = false;   
             mServerMessenger.send(message);
         }
         catch (RemoteException e)
         {

         }
         Log.d(TAG, "error = " + error); //$NON-NLS-1$
    }

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

    }

    @Override
    public void onPartialResults(Bundle partialResults)
    {

    }

    @Override
    public void onReadyForSpeech(Bundle params)
    {
        if (Build.VERSION.SDK_INT >= 16);//Build.VERSION_CODES.JELLY_BEAN)
        {
            mIsCountDownOn = true;
            mNoSpeechCountDown.start();
            mAudioManager.setStreamMute(AudioManager.STREAM_SYSTEM, false);
        }
        Log.d("TESTING: SPEECH SERVICE", "onReadyForSpeech"); //$NON-NLS-1$
    }

    @Override
    public void onResults(Bundle results)
    {
        ArrayList<String> data = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
        Log.d(TAG, (String) data.get(0));

        //mSpeechRecognizer.startListening(mSpeechRecognizerIntent);

        mIsListening = false;
        Message message = Message.obtain(null, MSG_RECOGNIZER_START_LISTENING);
        try
        {
               mServerMessenger.send(message);
        }
        catch (RemoteException e)
        {

        }

        Log.d(TAG, "onResults"); //$NON-NLS-1$
    }

    @Override
    public void onRmsChanged(float rmsdB)
    {

    }
}

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

公共类SpeechActivationService扩展服务
{
受保护的音频管理器；
受保护的语音识别器mSpeechRecognizer；
保护意图MSpeechRecognitizerIntent；
受保护的最终Messenger mServerMessenger=新Messenger（新入站管理器（此））；
保护布尔误听；
受保护的易失性布尔计数错误；
静态字符串TAG=“Icaro”；
静态最终整数消息识别器开始监听=1；
静态最终int MSG_识别器_CANCEL=2；
私有int-mBindFlag；
私人信使；
@凌驾
public void onCreate（）
{
super.onCreate（）；
mAudioManager=（AudioManager）getSystemService（Context.AUDIO\u服务）；
mSpeechRecognizer=SpeechRecognizer.createSpeechRecognizer（this）；
mSpeechRecognizer.setRecognitionListener（新建SpeechRecognitionListener（））；
mSpeechRecognizerIntent=新意图（RecognizerIntent.ACTION\u recognizer\u SPEECH）；
mSpeechRecognizerIntent.putExtra（RecognizerIntent.EXTRA_语言_模型，
识别者意图、语言、模型、自由形式）；
mSpeechRecognizerIntent.putExtra（RecognizerIntent.EXTRA_调用_包，
这个.getPackageName（））；
//mSpeechRecognizer.startListening（mSpeechRecognizerIntent）；
}
受保护的静态类IncomingHandler扩展处理程序
{
私有WeakReference mtarget；
收入管理者（演讲激活服务目标）
{
mtarget=新的WeakReference（目标）；
}
@凌驾
公共无效handleMessage（消息消息消息）
{
final SpeechActivationService target=mtarget.get（）；
开关（msg.what）
{
案例消息\u识别器\u开始\u侦听：
if（Build.VERSION.SDK\u INT>=16）；//Build.VERSION\u code.JELLY\u BEAN）
{
//关闭嘟嘟声
target.mAudioManager.setStreamMute（AudioManager.STREAM_SYSTEM，true）；
}
如果（！target.missending）
{
target.mSpeechRecognizer.startListening（target.mSpeechRecognizerIntent）；
target.mislisting=true；
Log.d（标记“消息开始侦听”）；//$NON-NLS-1$
}
打破
案例消息识别器取消：
target.mSpeechRecognizer.cancel（）；
target.mislisting=false；
Log.d（标记“消息取消识别器”）；//$NON-NLS-1$
打破
}
} 
} 
//果冻豆工作倒计时
受保护的倒计时mNoSpeechCountDown=新的倒计时（50005000）
{
@凌驾
公共void onTick（长毫秒未完成）
{
//TODO自动生成的方法存根
}
@凌驾
公共无效onFinish（）
{
mIsCountDownOn=false；
Message Message=Message.get（空，消息识别器\u取消）；
尝试
{
mServerMessenger.send（消息）；
message=message.get（空，消息识别器开始监听）；
mServerMessenger.send（消息）；
}
捕获（远程异常）
{
}
}
};
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）
{
//mSpeechRecognizer.startListening（mSpeechRecognizerIntent）；
尝试
{
Message msg=新消息（）；
msg.what=msg\u识别器\u启动\u侦听；
mServerMessenger.send（msg）；
}
捕获（远程异常）
{
}
返回开始时间不粘；
}
@凌驾
公共空间
{
super.ondestory（）；
如果（计算错误）
{
mNoSpeechCountDown.cancel（）；
}
if（mSpeechRecognizer！=null）
{
mSpeechRecognizer.destroy（）；
}
}
受保护类SpeechRecognitionListener实现了RecognitionListener
{
@凌驾
开始时的公共无效fSpeech（）
{
//语音输入将被处理，因此不再需要倒计时
如果（计算错误）
{
mIsCountDownOn=false；
mNoSpeechCountDown.cancel（）；
}               
Log.d（标记“onBeginingOfSpeech”）；//$NON-NLS-1$
}
@凌驾
已接收公共无效onBufferReceived（字节[]缓冲区）
{
字符串sTest=“”；
}
@凌驾
公共无效onEndOfSpeech（）
{
Log.d（“测试：语音服务”，“onEndOfSpeech”）；/$NON-NLS-1$
}
@凌驾
公共无效onError（内部错误）
{
如果（计算错误）
{
mIsCountDownOn=false；
mNoSpeechCountDown.cancel（）；
}
Message Message=Message.get（空，消息识别器开始监听）；
尝试
{
误听=错误；
mServerMessenger.send（消息）；
}
捕获（远程异常）
{
}
Log.d（标记“error=“+error）；//$NON-NLS-1$
}
@凌驾
public void onEvent（int eventType，Bundle参数）
{
}
@凌驾
public void onPartialResults（Bundle partialResults）
{
}
@凌驾
ReadyForSpeech上的公共void（Bundle参数）
{
if（Build.VERSION.SDK\u INT>=16）；//Build.VERSION\u code.JELLY\u BEAN）
{
mIsCountDownOn=true；
mNoSpeechCountDown.start（）；
mAudioManager.setStreamMute（AudioManager.STREAM_系统，false）；
}
Log.d（“测试：语音服务”，“onReadyForSpeech”）；/$NON-NLS-1$
}
@凌驾
公共结果（捆绑结果）
{
ArrayList data=results.getStringArrayList（SpeechRecognitor.results\u RECOGNITION）
            if (Build.VERSION.SDK_INT >= 16);//Build.VERSION_CODES.JELLY_BEAN)
            {
                // turn off beep sound  
                target.mAudioManager.setStreamMute(AudioManager.STREAM_SYSTEM, true);
            }
             if (!target.mIsListening)
             {
                mSpeechRecognizer = SpeechRecognizer.createSpeechRecognizer(this);
               mSpeechRecognizer.setRecognitionListener(new SpeechRecognitionListener());
               mSpeechRecognizerIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
               mSpeechRecognizerIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                                 RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
               mSpeechRecognizerIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE,
                                 this.getPackageName());


                 target.mSpeechRecognizer.startListening(target.mSpeechRecognizerIntent);
                 target.mIsListening = true;
                Log.d(TAG, "message start listening"); //$NON-NLS-1$
             }
             break;