| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.voicedialer; |
| |
| import android.app.Activity; |
| import android.content.Intent; |
| import android.speech.srec.MicrophoneInputStream; |
| import android.speech.srec.Recognizer; |
| import android.speech.srec.WaveHeader; |
| import android.util.Log; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| |
| /** |
| * This class is a framework for recognizing speech. It must be extended to use. |
| * The child class must timplement setupGrammar and onRecognitionSuccess. |
| * A usage cycle is as follows: |
| * <ul> |
| * <li>Create with a reference to the {@link VoiceDialerActivity}. |
| * <li>Signal the user to start speaking with the Vibrator or beep. |
| * <li>Start audio input by creating a {@link MicrophoneInputStream}. |
| * <li>Create and configure a {@link Recognizer}. |
| * <li>Set up the grammar using setupGrammar. |
| * <li>Start the {@link Recognizer} running using data already being |
| * collected by the microphone. |
| * <li>Wait for the {@link Recognizer} to complete. |
| * <li>Process the results using onRecognitionSuccess, which will pass |
| * a list of intents to the {@RecogizerClient}. |
| * <li>Shut down and clean up. |
| * </ul> |
| * Notes: |
| * <ul> |
| * <li>Audio many be read from a file. |
| * <li>A directory tree of audio files may be stepped through. |
| * <li>A contact list may be read from a file. |
| * <li>A {@link RecognizerLogger} may generate a set of log files from |
| * a recognition session. |
| * <li>A static instance of this class is held and reused by the |
| * {@link VoiceDialerActivity}, which saves setup time. |
| * </ul> |
| */ |
| abstract public class RecognizerEngine { |
| |
| protected static final String TAG = "RecognizerEngine"; |
| |
| protected static final String ACTION_RECOGNIZER_RESULT = |
| "com.android.voicedialer.ACTION_RECOGNIZER_RESULT"; |
| public static final String SENTENCE_EXTRA = "sentence"; |
| public static final String SEMANTIC_EXTRA = "semantic"; |
| |
| protected final String SREC_DIR = Recognizer.getConfigDir(null); |
| |
| protected static final String OPEN_ENTRIES = "openentries.txt"; |
| |
| protected static final int RESULT_LIMIT = 5; |
| |
| protected Activity mActivity; |
| protected Recognizer mSrec; |
| protected Recognizer.Grammar mSrecGrammar; |
| protected RecognizerLogger mLogger; |
| protected int mSampleRate; |
| |
| /** |
| * Constructor. |
| */ |
| public RecognizerEngine() { |
| mSampleRate = 0; |
| } |
| |
| abstract protected void setupGrammar() throws IOException, InterruptedException; |
| |
| abstract protected void onRecognitionSuccess(RecognizerClient recognizerClient) |
| throws InterruptedException; |
| |
| /** |
| * Start the recognition process. |
| * |
| * <ul> |
| * <li>Create and start the microphone. |
| * <li>Create a Recognizer. |
| * <li>set up the grammar (implementation is in child class) |
| * <li>Start the Recognizer. |
| * <li>Feed the Recognizer audio until it provides a result. |
| * <li>Build a list of Intents corresponding to the results. (implementation |
| * is in child class) |
| * <li>Stop the microphone. |
| * <li>Stop the Recognizer. |
| * </ul> |
| * |
| * @param recognizerClient client to be given the results |
| * @param activity the Activity this recognition is being run from. |
| * @param micFile optional audio input from this file, or directory tree. |
| * @param sampleRate the same rate coming from the mic or micFile |
| */ |
| public void recognize(RecognizerClient recognizerClient, Activity activity, |
| File micFile, int sampleRate) { |
| InputStream mic = null; |
| boolean recognizerStarted = false; |
| try { |
| mActivity = activity; |
| // set up logger |
| mLogger = null; |
| if (RecognizerLogger.isEnabled(mActivity)) { |
| mLogger = new RecognizerLogger(mActivity); |
| } |
| |
| if (mSampleRate != sampleRate) { |
| // sample rate has changed since we last used this recognizerEngine. |
| // destroy the grammar and regenerate. |
| if (mSrecGrammar != null) { |
| mSrecGrammar.destroy(); |
| } |
| mSrecGrammar = null; |
| mSampleRate = sampleRate; |
| } |
| |
| // create a new recognizer |
| if (false) Log.d(TAG, "start new Recognizer"); |
| if (mSrec == null) { |
| String parFilePath = SREC_DIR + "/baseline11k.par"; |
| if (sampleRate == 8000) { |
| parFilePath = SREC_DIR + "/baseline8k.par"; |
| } |
| mSrec = new Recognizer(parFilePath); |
| } |
| |
| // start audio input |
| if (micFile != null) { |
| if (false) Log.d(TAG, "using mic file"); |
| mic = new FileInputStream(micFile); |
| WaveHeader hdr = new WaveHeader(); |
| hdr.read(mic); |
| } else { |
| if (false) Log.d(TAG, "start new MicrophoneInputStream"); |
| mic = new MicrophoneInputStream(sampleRate, sampleRate * 15); |
| } |
| |
| // notify UI |
| recognizerClient.onMicrophoneStart(mic); |
| |
| // log audio if requested |
| if (mLogger != null) mic = mLogger.logInputStream(mic, sampleRate); |
| |
| setupGrammar(); |
| |
| // start the recognition process |
| if (false) Log.d(TAG, "start mSrec.start"); |
| mSrec.start(); |
| recognizerStarted = true; |
| |
| // recognize |
| while (true) { |
| if (Thread.interrupted()) throw new InterruptedException(); |
| int event = mSrec.advance(); |
| if (event != Recognizer.EVENT_INCOMPLETE && |
| event != Recognizer.EVENT_NEED_MORE_AUDIO) { |
| Log.d(TAG, "start advance()=" + |
| Recognizer.eventToString(event) + |
| " avail " + mic.available()); |
| } |
| switch (event) { |
| case Recognizer.EVENT_INCOMPLETE: |
| case Recognizer.EVENT_STARTED: |
| case Recognizer.EVENT_START_OF_VOICING: |
| case Recognizer.EVENT_END_OF_VOICING: |
| continue; |
| case Recognizer.EVENT_RECOGNITION_RESULT: |
| onRecognitionSuccess(recognizerClient); |
| break; |
| case Recognizer.EVENT_NEED_MORE_AUDIO: |
| mSrec.putAudio(mic); |
| continue; |
| default: |
| Log.d(TAG, "unknown event " + event); |
| recognizerClient.onRecognitionFailure(Recognizer.eventToString(event)); |
| break; |
| } |
| break; |
| } |
| |
| } catch (InterruptedException e) { |
| if (false) Log.d(TAG, "start interrupted " + e); |
| recognizerClient.onRecognitionError(e.toString()); |
| } catch (IOException e) { |
| if (false) Log.d(TAG, "start new Srec failed " + e); |
| recognizerClient.onRecognitionError(e.toString()); |
| } catch (Exception e) { |
| if (false) Log.d(TAG, "exception " + e); |
| recognizerClient.onRecognitionError(e.toString()); |
| } finally { |
| if (false) Log.d(TAG, "start mSrec.stop"); |
| if (mSrec != null && recognizerStarted) mSrec.stop(); |
| |
| // stop microphone |
| try { |
| if (mic != null) mic.close(); |
| } |
| catch (IOException ex) { |
| if (false) Log.d(TAG, "start - mic.close failed - " + ex); |
| } |
| mic = null; |
| |
| // close logger |
| try { |
| if (mLogger != null) mLogger.close(); |
| } |
| catch (IOException ex) { |
| if (false) Log.d(TAG, "start - mLoggger.close failed - " + ex); |
| } |
| mLogger = null; |
| } |
| if (false) Log.d(TAG, "start bye"); |
| } |
| |
| protected static void addIntent(ArrayList<Intent> intents, Intent intent) { |
| for (Intent in : intents) { |
| if (in.getAction() != null && |
| in.getAction().equals(intent.getAction()) && |
| in.getData() != null && |
| in.getData().equals(intent.getData())) { |
| return; |
| } |
| } |
| intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK); |
| intents.add(intent); |
| } |
| } |
