Android语音识别服务，无论是否通知

首先，我知道在后台或服务中已经有很多关于语音识别的问题。我想我在两周内检查了所有的答案：P。但我不理解所有的答案。我也使用了那里的代码，但它不起作用。 我想要的是，当用户点击一个按钮启动语音识别服务时，该服务就会启动，甚至安卓系统也会被锁定。该服务会听取用户的指示。 有人能告诉我如何实现这个或任何教程吗。 我从两个星期开始做这个。我在谷歌上搜索了很多东西，也是如此

=========================更新============================== 我正在调用MainActivity中的一个服务，但该服务已启动，并且也收到了消息，但RecognitionListener类方法未启动。我用的是这个代码

谁能告诉我我的代码出了什么问题

这是主要的活动

package com.android.jarvis.voicerecognitionservice;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Build;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import static com.android.jarvis.voicerecognitionservice.BuildConfig.DEBUG;

public class MainActivity extends AppCompatActivity {
    static final String TAG = "Service";
    private int mBindFlag;
    private Messenger mServiceMessenger;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
//        Intent service = new Intent(MainActivity, RecognitionService.class);
        startService(new Intent(this, RecognitionService.class));
        mBindFlag = Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH ? 0 : Context.BIND_ABOVE_CLIENT;

    }
    @Override
    protected void onStart()
    {
        super.onStart();
        bindService(new Intent(this, RecognitionService.class), mServiceConnection, mBindFlag);
    }
    @Override
    protected void onStop()
    {
        super.onStop();

        if (mServiceMessenger != null)
        {
            unbindService(mServiceConnection);
            mServiceMessenger = null;
        }
    }
    private final ServiceConnection mServiceConnection = new ServiceConnection()
    {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service)
        {
            if (DEBUG) {Log.d(TAG, "onServiceConnected");} //$NON-NLS-1$

            mServiceMessenger = new Messenger(service);
            Message msg = new Message();
            msg.what = RecognitionService.MSG_RECOGNIZER_START_LISTENING;

            try
            {
                mServiceMessenger.send(msg);
                Log.d(TAG,"Message Sent");
            }
            catch (RemoteException e)
            {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name)
        {
            if (DEBUG) {
                Log.d(TAG, "onServiceDisconnected");} //$NON-NLS-1$
            mServiceMessenger = null;
        }

    }; //
}

package com.android.jarvis.voicerecognitionservice；
导入android.content.ComponentName；
导入android.content.Context；
导入android.content.Intent；
导入android.content.ServiceConnection；
导入android.os.Build；
导入android.os.IBinder；
导入android.os.Message；
导入android.os.Messenger；
导入android.os.RemoteException；
导入android.support.v7.app.AppActivity；
导入android.os.Bundle；
导入android.util.Log；
导入静态com.android.jarvis.voicerecognitionservice.BuildConfig.DEBUG；
公共类MainActivity扩展了AppCompatActivity{
静态最终字符串TAG=“Service”；
私有int-mBindFlag；
私人信使；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
//意向服务=新意向（MainActivity，RecognitionService.class）；
startService（新意图（此，RecognitionService.class））；
mBindFlag=Build.VERSION.SDK\u INT

这是认可服务

    package com.android.jarvis.voicerecognitionservice;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import android.os.Build;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.speech.RecognitionListener;
import android.speech.RecognizerIntent;
import android.speech.SpeechRecognizer;
import android.util.Log;
import android.widget.Toast;

import java.lang.ref.WeakReference;

import static com.android.jarvis.voicerecognitionservice.MainActivity.TAG;


public class RecognitionService extends Service {
    static AudioManager mAudioManager;
    protected SpeechRecognizer mSpeechRecognizer;
    protected Intent mSpeechRecognizerIntent;
    protected final Messenger mServerMessenger = new Messenger(new IncomingHandler(this));

    static boolean mIsListening;
    static volatile boolean mIsCountDownOn;
    static boolean mIsStreamSolo;

    static final int MSG_RECOGNIZER_START_LISTENING = 1;
    static final int MSG_RECOGNIZER_CANCEL = 2;
    @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());
        Toast.makeText(this, "Service Started", Toast.LENGTH_SHORT).show();
    }

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

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


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

            switch (msg.what)
            {
                case MSG_RECOGNIZER_START_LISTENING:

                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
                    {
                        // turn off beep sound
//                        if (!mIsStreamSolo)
//                        {
//                            mAudioManager.setStreamSolo(AudioManager.STREAM_VOICE_CALL, true);
//                            mIsStreamSolo = 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:
                    if (mIsStreamSolo)
                    {
                        mAudioManager.setStreamSolo(AudioManager.STREAM_VOICE_CALL, false);
                        mIsStreamSolo = false;
                    }
                    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 void onDestroy()
    {
        super.onDestroy();

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

        @Override
        public IBinder onBind(Intent intent)
        {
            Log.d(TAG, "onBind");  //$NON-NLS-1$

            return mServerMessenger.getBinder();
        }


    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)
        {

        }

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

        @Override
        public void onError(int error)
        {
            if (mIsCountDownOn)
            {
                mIsCountDownOn = false;
                mNoSpeechCountDown.cancel();
            }
            mIsListening = false;
            Message message = Message.obtain(null, MSG_RECOGNIZER_START_LISTENING);
            try
            {
                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 >= Build.VERSION_CODES.JELLY_BEAN)
            {
                mIsCountDownOn = true;
                mNoSpeechCountDown.start();

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

        @Override
        public void onResults(Bundle results)
        {
            Log.d(TAG, "onResults"); //$NON-NLS-1$

        }

        @Override
        public void onRmsChanged(float rmsdB)
        {

        }

    }

}

package com.android.jarvis.voicerecognitionservice；
导入android.app.Service；
导入android.content.Context；
导入android.content.Intent；
导入android.media.AudioManager；
导入android.os.Build；
导入android.os.Bundle；
导入android.os.CountDownTimer；
导入android.os.Handler；
导入android.os.IBinder；
导入android.os.Message；
导入android.os.Messenger；
导入android.os.RemoteException；
导入android.speech.RecognitionListener；
导入android.speech.RecognizerIntent；
导入android.SpeechRecognizer；
导入android.util.Log；
导入android.widget.Toast；
导入java.lang.ref.WeakReference；
导入静态com.android.jarvis.voicerecognitionservice.MainActivity.TAG；
公共类识别服务扩展了服务{
静态音频管理器；
受保护的语音识别器mSpeechRecognizer；
保护意图MSpeechRecognitizerIntent；
受保护的最终Messenger mServerMessenger=新Messenger（新入站管理器（此））；
静态布尔误听；
静态易失布尔错误计数；
静态布尔错流；
静态最终整数消息识别器开始监听=1；
静态最终int MSG_识别器_CANCEL=2；
@凌驾
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（））；
Toast.makeText（此“服务已启动”，Toast.LENGTH_SHORT）.show（）；
}
受保护的静态类IncomingHandler扩展处理程序
{
私有WeakReference mtarget；
收入管理人（认可服务目标）
{
mtarget=新的WeakReference（目标）；
}
@凌驾
公共无效handleMessage（消息消息消息）
{
最终识别服务目标=mtarget.get（）；
开关（msg.what）
{
案例消息\u识别器\u开始\u侦听：
if（Build.VERSION.SDK\u INT>=Build.VERSION\u code.JELLY\u BEAN）
{
//t