diff options
Diffstat (limited to 'core/java')
| -rw-r--r-- | core/java/android/speech/IRecognitionListener.aidl | 49 | ||||
| -rw-r--r-- | core/java/android/speech/IRecognitionService.aidl | 43 | ||||
| -rw-r--r-- | core/java/android/speech/RecognitionListener.java | 96 | ||||
| -rw-r--r-- | core/java/android/speech/RecognitionManager.java | 321 | ||||
| -rw-r--r-- | core/java/android/speech/RecognitionResult.aidl | 19 | ||||
| -rw-r--r-- | core/java/android/speech/RecognitionResult.java | 220 | ||||
| -rw-r--r-- | core/java/android/speech/RecognitionServiceUtil.java | 101 | ||||
| -rw-r--r-- | core/java/android/speech/RecognizerIntent.java | 43 |
8 files changed, 522 insertions, 370 deletions
diff --git a/core/java/android/speech/IRecognitionListener.aidl b/core/java/android/speech/IRecognitionListener.aidl index 2da2258b4ee1..5b48bd2fdc6b 100644 --- a/core/java/android/speech/IRecognitionListener.aidl +++ b/core/java/android/speech/IRecognitionListener.aidl @@ -17,7 +17,6 @@ package android.speech; import android.os.Bundle; -import android.speech.RecognitionResult; /** * Listener for speech recognition events, used with RecognitionService. @@ -26,35 +25,55 @@ import android.speech.RecognitionResult; * {@hide} */ interface IRecognitionListener { - /** Called when the endpointer is ready for the user to start speaking. */ - void onReadyForSpeech(in Bundle noiseParams); + /** + * Called when the endpointer is ready for the user to start speaking. + * + * @param params parameters set by the recognition service. Reserved for future use. + */ + void onReadyForSpeech(in Bundle params); - /** The user has started to speak. */ + /** + * The user has started to speak. + */ void onBeginningOfSpeech(); - /** The sound level in the audio stream has changed. */ + /** + * The sound level in the audio stream has changed. + * + * @param rmsdB the new RMS dB value + */ void onRmsChanged(in float rmsdB); /** - * More sound has been received. Buffer is a byte buffer containing - * a sequence of 16-bit shorts. + * More sound has been received. + * + * @param buffer the byte buffer containing a sequence of 16-bit shorts. */ void onBufferReceived(in byte[] buffer); - /** Called after the user stops speaking. */ + /** + * Called after the user stops speaking. + */ void onEndOfSpeech(); /** - * A network or recognition error occurred. The code is defined in - * {@link android.speech.RecognitionResult} + * A network or recognition error occurred. + * + * @param error code is defined in {@link RecognitionManager} */ void onError(in int error); - /** + /** * Called when recognition results are ready. - * @param results: an ordered list of the most likely results (N-best list). - * @param key: a key associated with the results. The same results can - * be retrieved asynchronously later using the key, if available. + * + * @param results a Bundle containing the most likely results (N-best list). + */ + void onResults(in Bundle results); + + /** + * Called when recognition partial results are ready. + * + * @param results a Bundle containing the current most likely result. */ - void onResults(in List<RecognitionResult> results, long key); + void onPartialResults(in Bundle results); } diff --git a/core/java/android/speech/IRecognitionService.aidl b/core/java/android/speech/IRecognitionService.aidl index a18c380c9e70..ca9af1505d73 100644 --- a/core/java/android/speech/IRecognitionService.aidl +++ b/core/java/android/speech/IRecognitionService.aidl @@ -16,22 +16,41 @@ package android.speech; +import android.os.Bundle; import android.content.Intent; import android.speech.IRecognitionListener; -import android.speech.RecognitionResult; -// A Service interface to speech recognition. Call startListening when -// you want to begin capturing audio; RecognitionService will automatically -// determine when the user has finished speaking, stream the audio to the -// recognition servers, and notify you when results are ready. -/** {@hide} */ +/** +* A Service interface to speech recognition. Call startListening when +* you want to begin capturing audio; RecognitionService will automatically +* determine when the user has finished speaking, stream the audio to the +* recognition servers, and notify you when results are ready. In most of the cases, +* this class should not be used directly, instead use {@link RecognitionManager} for +* accessing recognition service. +* {@hide} +*/ interface IRecognitionService { - // Start listening for speech. Can only call this from one thread at once. - // see RecognizerIntent.java for constants used to specify the intent. - void startListening(in Intent recognizerIntent, - in IRecognitionListener listener); - - List<RecognitionResult> getRecognitionResults(in long key); + /** + * Starts listening for speech. Please note that the recognition service supports + * one listener only, therefore, if this function is called from two different threads, + * only the latest one will get the notifications + * + * @param recognizerIntent the intent from which the invocation occurred. Additionally, + * this intent can contain extra parameters to manipulate the behavior of the recognition + * client. For more information see {@link RecognizerIntent}. + * @param listener to receive callbacks + */ + void startListening(in Intent recognizerIntent, in IRecognitionListener listener); + /** + * Stops listening for speech. Speech captured so far will be recognized as + * if the user had stopped speaking at this point. The function has no effect unless it + * is called during the speech capturing. + */ + void stopListening(); + + /** + * Cancels the speech recognition. + */ void cancel(); } diff --git a/core/java/android/speech/RecognitionListener.java b/core/java/android/speech/RecognitionListener.java new file mode 100644 index 000000000000..eab3f4004014 --- /dev/null +++ b/core/java/android/speech/RecognitionListener.java @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2010 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 android.speech; + +import android.content.Intent; +import android.os.Bundle; + +/** + * Used for receiving notifications from the RecognitionManager when the + * recognition related events occur. All the callbacks are executed on the + * Application main thread. + */ +public interface RecognitionListener { + + /** + * Called when RecognitionManager is successfully initialized + */ + void onInit(); + + /** + * Called when the endpointer is ready for the user to start speaking. + * + * @param params parameters set by the recognition service. Reserved for future use. + */ + void onReadyForSpeech(Bundle params); + + /** + * The user has started to speak. + */ + void onBeginningOfSpeech(); + + /** + * The sound level in the audio stream has changed. There is no guarantee that this method will + * be called. + * + * @param rmsdB the new RMS dB value + */ + void onRmsChanged(float rmsdB); + + /** + * More sound has been received. The purpose of this function is to allow giving feedback to the + * user regarding the captured audio. There is no guarantee that this method will be called. + * + * @param buffer a buffer containing a sequence of big-endian 16-bit integers representing a + * single channel audio stream. The sample rate is implementation dependent. + */ + void onBufferReceived(byte[] buffer); + + /** + * Called after the user stops speaking. + */ + void onEndOfSpeech(); + + /** + * A network or recognition error occurred. + * + * @param error code is defined in {@link RecognitionManager} + */ + void onError(int error); + + /** + * Called when recognition results are ready. + * + * @param results the recognition results. To retrieve the results in {@code + * ArrayList<String>} format use {@link Bundle#getStringArrayList(String)} with + * {@link RecognitionManager#RECOGNITION_RESULTS_STRING_ARRAY} as a parameter + */ + void onResults(Bundle results); + + /** + * Called when partial recognition results are available. The callback might be called at any + * time between {@link #onBeginningOfSpeech()} and {@link #onResults(Bundle)} when partial + * results are ready. This method may be called zero, one or multiple times for each call to + * {@link RecognitionManager#startListening(Intent)}, depending on the speech recognition + * service implementation. + * + * @param partialResults the returned results. To retrieve the results in + * ArrayList<String> format use {@link Bundle#getStringArrayList(String)} with + * {@link RecognitionManager#RECOGNITION_RESULTS_STRING_ARRAY} as a parameter + */ + void onPartialResults(Bundle partialResults); + +} diff --git a/core/java/android/speech/RecognitionManager.java b/core/java/android/speech/RecognitionManager.java new file mode 100644 index 000000000000..79ae48030698 --- /dev/null +++ b/core/java/android/speech/RecognitionManager.java @@ -0,0 +1,321 @@ +/* + * Copyright (C) 2010 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 android.speech; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.content.pm.ResolveInfo; +import android.os.Bundle; +import android.os.IBinder; +import android.os.RemoteException; +import android.util.Log; + +import java.util.List; + +/** + * This class provides access to the speech recognition service. This service allows access to the + * speech recognizer. Do not instantiate this class directly, instead, call + * {@link RecognitionManager#createRecognitionManager(Context, RecognitionListener, Intent)}. This + * class is not thread safe and must be synchronized externally if accessed from multiple threads. + */ +public class RecognitionManager { + /** DEBUG value to enable verbose debug prints */ + private final static boolean DBG = false; + + /** Log messages identifier */ + private static final String TAG = "RecognitionManager"; + + /** + * Used to retrieve an {@code ArrayList<String>} from the {@link Bundle} passed to the + * {@link RecognitionListener#onResults(Bundle)} and + * {@link RecognitionListener#onPartialResults(Bundle)} methods. These strings are the possible + * recognition results, where the first element is the most likely candidate. + */ + public static final String RECOGNITION_RESULTS_STRING_ARRAY = + "recognition_results_string_array"; + + /** The actual RecognitionService endpoint */ + private IRecognitionService mService; + + /** The connection to the actual service */ + private Connection mConnection; + + /** Context with which the manager was created */ + private final Context mContext; + + /** Listener that will receive all the callbacks */ + private final RecognitionListener mListener; + + /** Helper class wrapping the IRecognitionListener */ + private final InternalRecognitionListener mInternalRecognitionListener; + + /** Network operation timed out. */ + public static final int NETWORK_TIMEOUT_ERROR = 1; + + /** Other network related errors. */ + public static final int NETWORK_ERROR = 2; + + /** Audio recording error. */ + public static final int AUDIO_ERROR = 3; + + /** Server sends error status. */ + public static final int SERVER_ERROR = 4; + + /** Other client side errors. */ + public static final int CLIENT_ERROR = 5; + + /** No speech input */ + public static final int SPEECH_TIMEOUT_ERROR = 6; + + /** No recognition result matched. */ + public static final int NO_MATCH_ERROR = 7; + + /** RecognitionService busy. */ + public static final int SERVER_BUSY_ERROR = 8; + + /** + * RecognitionManager was not initialized yet, most probably because + * {@link RecognitionListener#onInit()} was not called yet. + */ + public static final int MANAGER_NOT_INITIALIZED_ERROR = 9; + + /** + * The right way to create a RecognitionManager is by using + * {@link #createRecognitionManager} static factory method + */ + private RecognitionManager(final RecognitionListener listener, final Context context) { + mInternalRecognitionListener = new InternalRecognitionListener(); + mContext = context; + mListener = listener; + } + + /** + * Basic ServiceConnection which just records mService variable. + */ + private class Connection implements ServiceConnection { + + public synchronized void onServiceConnected(final ComponentName name, + final IBinder service) { + mService = IRecognitionService.Stub.asInterface(service); + if (mListener != null) { + mListener.onInit(); + } + if (DBG) Log.d(TAG, "onServiceConnected - Success"); + } + + public void onServiceDisconnected(final ComponentName name) { + mService = null; + mConnection = null; + if (DBG) Log.d(TAG, "onServiceDisconnected - Success"); + } + } + + /** + * Checks whether a speech recognition service is available on the system. If this method + * returns {@code false}, + * {@link RecognitionManager#createRecognitionManager(Context, RecognitionListener, Intent)} + * will fail. + * + * @param context with which RecognitionManager will be created + * @return {@code true} if recognition is available, {@code false} otherwise + */ + public static boolean isRecognitionAvailable(final Context context) { + final List<ResolveInfo> list = context.getPackageManager().queryIntentServices( + new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0); + return list != null && list.size() != 0; + } + + /** + * Factory method to create a new RecognitionManager + * + * @param context in which to create RecognitionManager + * @param listener that will receive all the callbacks from the created + * {@link RecognitionManager} + * @param recognizerIntent contains initialization parameters for the speech recognizer. The + * intent action should be {@link RecognizerIntent#ACTION_RECOGNIZE_SPEECH}. Future + * versions of this API may add startup parameters for speech recognizer. + * @return null if a recognition service implementation is not installed or if speech + * recognition is not supported by the device, otherwise a new RecognitionManager is + * returned. The created RecognitionManager can only be used after the + * {@link RecognitionListener#onInit()} method has been called. + */ + public static RecognitionManager createRecognitionManager(final Context context, + final RecognitionListener listener, final Intent recognizerIntent) { + if (context == null || recognizerIntent == null) { + throw new IllegalArgumentException( + "Context and recognizerListener argument cannot be null)"); + } + RecognitionManager manager = new RecognitionManager(listener, context); + manager.mConnection = manager.new Connection(); + if (!context.bindService(recognizerIntent, manager.mConnection, Context.BIND_AUTO_CREATE)) { + Log.e(TAG, "bind to recognition service failed"); + listener.onError(CLIENT_ERROR); + return null; + } + return manager; + } + + /** + * Checks whether the service is connected + * + * @param functionName from which the call originated + * @return {@code true} if the service was successfully initialized, {@code false} otherwise + */ + private boolean connectToService(final String functionName) { + if (mService != null) { + return true; + } + if (mConnection == null) { + if (DBG) Log.d(TAG, "restarting connection to the recognition service"); + mConnection = new Connection(); + mContext.bindService(new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), mConnection, + Context.BIND_AUTO_CREATE); + } + mInternalRecognitionListener.onError(MANAGER_NOT_INITIALIZED_ERROR); + Log.e(TAG, functionName + " was called before service connection was initialized"); + return false; + } + + /** + * Starts listening for speech. + * + * @param recognizerIntent contains parameters for the recognition to be performed. The intent + * action should be {@link RecognizerIntent#ACTION_RECOGNIZE_SPEECH}. The intent may also + * contain optional extras, see {@link RecognizerIntent}. If these values are not set + * explicitly, default values will be used by the recognizer. + */ + public void startListening(Intent recognizerIntent) { + if (recognizerIntent == null) { + throw new IllegalArgumentException("recognizerIntent argument cannot be null"); + } + if (!connectToService("startListening")) { + return; // service is not connected yet, reconnect in progress + } + try { + mService.startListening(recognizerIntent, mInternalRecognitionListener); + if (DBG) Log.d(TAG, "service start listening command succeded"); + } catch (final RemoteException e) { + Log.e(TAG, "startListening() failed", e); + mInternalRecognitionListener.onError(CLIENT_ERROR); + } + } + + /** + * Stops listening for speech. Speech captured so far will be recognized as if the user had + * stopped speaking at this point. Note that in the default case, this does not need to be + * called, as the speech endpointer will automatically stop the recognizer listening when it + * determines speech has completed. However, you can manipulate endpointer parameters directly + * using the intent extras defined in {@link RecognizerIntent}, in which case you may sometimes + * want to manually call this method to stop listening sooner. + */ + public void stopListening() { + if (mService == null) { + return; // service is not connected, but no need to reconnect at this point + } + try { + mService.stopListening(); + if (DBG) Log.d(TAG, "service stop listening command succeded"); + } catch (final RemoteException e) { + Log.e(TAG, "stopListening() failed", e); + mInternalRecognitionListener.onError(CLIENT_ERROR); + } + } + + /** + * Cancels the speech recognition. + */ + public void cancel() { + if (mService == null) { + return; // service is not connected, but no need to reconnect at this point + } + try { + mService.cancel(); + if (DBG) Log.d(TAG, "service cancel command succeded"); + } catch (final RemoteException e) { + Log.e(TAG, "cancel() failed", e); + mInternalRecognitionListener.onError(CLIENT_ERROR); + } + } + + /** + * Destroys the RecognitionManager object. Note that after calling this method all method calls + * on this object will fail, triggering {@link RecognitionListener#onError}. + */ + public void destroy() { + if (mConnection != null) { + mContext.unbindService(mConnection); + } + mService = null; + } + + /** + * Internal wrapper of IRecognitionListener which will propagate the results + * to RecognitionListener + */ + private class InternalRecognitionListener extends IRecognitionListener.Stub { + + public void onBeginningOfSpeech() { + if (mListener != null) { + mListener.onBeginningOfSpeech(); + } + } + + public void onBufferReceived(final byte[] buffer) { + if (mListener != null) { + mListener.onBufferReceived(buffer); + } + } + + public void onEndOfSpeech() { + if (mListener != null) { + mListener.onEndOfSpeech(); + } + } + + public void onError(final int error) { + if (mListener != null) { + mListener.onError(error); + } + } + + public void onReadyForSpeech(final Bundle noiseParams) { + if (mListener != null) { + mListener.onReadyForSpeech(noiseParams); + } + } + + public void onResults(final Bundle results) { + if (mListener != null) { + mListener.onResults(results); + } + } + + public void onPartialResults(final Bundle results) { + if (mListener != null) { + mListener.onPartialResults(results); + } + } + + public void onRmsChanged(final float rmsdB) { + if (mListener != null) { + mListener.onRmsChanged(rmsdB); + } + } + } +} diff --git a/core/java/android/speech/RecognitionResult.aidl b/core/java/android/speech/RecognitionResult.aidl deleted file mode 100644 index 59e53ab86fd1..000000000000 --- a/core/java/android/speech/RecognitionResult.aidl +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (C) 2009 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 android.speech; - -parcelable RecognitionResult; diff --git a/core/java/android/speech/RecognitionResult.java b/core/java/android/speech/RecognitionResult.java deleted file mode 100644 index 95715eed4107..000000000000 --- a/core/java/android/speech/RecognitionResult.java +++ /dev/null @@ -1,220 +0,0 @@ -/* - * Copyright (C) 2009 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 android.speech; - -import android.os.Parcel; -import android.os.Parcelable; - -/** - * RecognitionResult is a passive object that stores a single recognized query - * and its search result. - * - * TODO: Revisit and improve this class, reconciling the different types of actions and - * the different ways they are represented. Maybe we should have a separate result object - * for each type, and put them (type/value) in bundle? - * {@hide} - */ -public class RecognitionResult implements Parcelable { - /** - * Status of the recognize request. - */ - public static final int NETWORK_TIMEOUT = 1; // Network operation timed out. - - public static final int NETWORK_ERROR = 2; // Other network related errors. - - public static final int AUDIO_ERROR = 3; // Audio recording error. - - public static final int SERVER_ERROR = 4; // Server sends error status. - - public static final int CLIENT_ERROR = 5; // Other client side errors. - - public static final int SPEECH_TIMEOUT = 6; // No speech input - - public static final int NO_MATCH = 7; // No recognition result matched. - - public static final int SERVICE_BUSY = 8; // RecognitionService busy. - - /** - * Type of the recognition results. - */ - public static final int RAW_RECOGNITION_RESULT = 0; - - public static final int WEB_SEARCH_RESULT = 1; - - public static final int CONTACT_RESULT = 2; - - public static final int ACTION_RESULT = 3; - - /** - * A factory method to create a raw RecognitionResult - * - * @param sentence the recognized text. - */ - public static RecognitionResult newRawRecognitionResult(String sentence) { - return new RecognitionResult(RAW_RECOGNITION_RESULT, sentence, null, null); - } - - /** - * A factory method to create a RecognitionResult for contacts. - * - * @param contact the contact name. - * @param phoneType the phone type. - * @param callAction whether this result included a command to "call", or - * just the contact name. - */ - public static RecognitionResult newContactResult(String contact, int phoneType, - boolean callAction) { - return new RecognitionResult(CONTACT_RESULT, contact, phoneType, callAction); - } - - /** - * A factory method to create a RecognitionResult for a web search query. - * - * @param query the query string. - * @param html the html page of the search result. - * @param url the url that performs the search with the query. - */ - public static RecognitionResult newWebResult(String query, String html, String url) { - return new RecognitionResult(WEB_SEARCH_RESULT, query, html, url); - } - - /** - * A factory method to create a RecognitionResult for an action. - * - * @param action the action type - * @param query the query string associated with that action. - */ - public static RecognitionResult newActionResult(int action, String query) { - return new RecognitionResult(ACTION_RESULT, action, query); - } - - public static final Parcelable.Creator<RecognitionResult> CREATOR = - new Parcelable.Creator<RecognitionResult>() { - - public RecognitionResult createFromParcel(Parcel in) { - return new RecognitionResult(in); - } - - public RecognitionResult[] newArray(int size) { - return new RecognitionResult[size]; - } - }; - - /** - * Result type. - */ - public final int mResultType; - - /** - * The recognized string when mResultType is WEB_SEARCH_RESULT. The name of - * the contact when mResultType is CONTACT_RESULT. The relevant query when - * mResultType is ACTION_RESULT. - */ - public final String mText; - - /** - * The HTML result page for the query. If this is null, then the application - * must use the url field to get the HTML result page. - */ - public final String mHtml; - - /** - * The url to get the result page for the query string. The application must - * use this url instead of performing the search with the query. - */ - public final String mUrl; - - /** - * Phone number type. This is valid only when mResultType == CONTACT_RESULT. - */ - public final int mPhoneType; - - /** - * Action type. This is valid only when mResultType == ACTION_RESULT. - */ - public final int mAction; - - /** - * Whether a contact recognition result included a command to "call". This - * is valid only when mResultType == CONTACT_RESULT. - */ - public final boolean mCallAction; - - private RecognitionResult(int type, int action, String query) { - mResultType = type; - mAction = action; - mText = query; - mHtml = null; - mUrl = null; - mPhoneType = -1; - mCallAction = false; - } - - private RecognitionResult(int type, String query, String html, String url) { - mResultType = type; - mText = query; - mHtml = html; - mUrl = url; - mPhoneType = -1; - mAction = -1; - mCallAction = false; - } - - private RecognitionResult(int type, String query, int phoneType, boolean callAction) { - mResultType = type; - mText = query; - mPhoneType = phoneType; - mHtml = null; - mUrl = null; - mAction = -1; - mCallAction = callAction; - } - - private RecognitionResult(Parcel in) { - mResultType = in.readInt(); - mText = in.readString(); - mHtml = in.readString(); - mUrl = in.readString(); - mPhoneType = in.readInt(); - mAction = in.readInt(); - mCallAction = (in.readInt() == 1); - } - - public void writeToParcel(Parcel out, int flags) { - out.writeInt(mResultType); - out.writeString(mText); - out.writeString(mHtml); - out.writeString(mUrl); - out.writeInt(mPhoneType); - out.writeInt(mAction); - out.writeInt(mCallAction ? 1 : 0); - } - - @Override - public String toString() { - String resultType[] = { - "RAW", "WEB", "CONTACT", "ACTION" - }; - return "[type=" + resultType[mResultType] + ", text=" + mText + ", mUrl=" + mUrl - + ", html=" + mHtml + ", mAction=" + mAction + ", mCallAction=" + mCallAction + "]"; - } - - public int describeContents() { - // no special description - return 0; - } -} diff --git a/core/java/android/speech/RecognitionServiceUtil.java b/core/java/android/speech/RecognitionServiceUtil.java deleted file mode 100644 index 4207543256a3..000000000000 --- a/core/java/android/speech/RecognitionServiceUtil.java +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (C) 2009 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 android.speech; - -import android.content.ComponentName; -import android.content.Intent; -import android.content.ServiceConnection; -import android.os.Bundle; -import android.os.IBinder; -import android.os.RemoteException; -import android.speech.RecognitionResult; -import android.util.Log; - -import java.util.List; - -/** - * Utils for Google's network-based speech recognizer, which lets you perform - * speech-to-text translation through RecognitionService. IRecognitionService - * and IRecognitionListener are the core interfaces; you begin recognition - * through IRecognitionService and subscribe to callbacks about when the user - * stopped speaking, results come in, errors, etc. through IRecognitionListener. - * RecognitionServiceUtil includes default IRecognitionListener and - * ServiceConnection implementations to reduce the amount of boilerplate. - * - * The Service provides no user interface. See RecognitionActivity if you - * want the standard voice search UI. - * - * Below is a small skeleton of how to use the recognizer: - * - * ServiceConnection conn = new RecognitionServiceUtil.Connection(); - * mContext.bindService(RecognitionServiceUtil.sDefaultIntent, - * conn, Context.BIND_AUTO_CREATE); - * IRecognitionListener listener = new RecognitionServiceWrapper.NullListener() { - * public void onResults(List<String> results) { - * // Do something with recognition transcripts - * } - * } - * - * // Must wait for conn.mService to be populated, then call below - * conn.mService.startListening(null, listener); - * - * {@hide} - */ -public class RecognitionServiceUtil { - public static final Intent sDefaultIntent = new Intent( - RecognizerIntent.ACTION_RECOGNIZE_SPEECH); - - // Recognize request parameters - public static final String USE_LOCATION = "useLocation"; - public static final String CONTACT_AUTH_TOKEN = "contactAuthToken"; - - // Bundles - public static final String NOISE_LEVEL = "NoiseLevel"; - public static final String SIGNAL_NOISE_RATIO = "SignalNoiseRatio"; - - private RecognitionServiceUtil() {} - - /** - * IRecognitionListener which does nothing in response to recognition - * callbacks. You can subclass from this and override only the methods - * whose events you want to respond to. - */ - public static class NullListener extends IRecognitionListener.Stub { - public void onReadyForSpeech(Bundle bundle) {} - public void onBeginningOfSpeech() {} - public void onRmsChanged(float rmsdB) {} - public void onBufferReceived(byte[] buf) {} - public void onEndOfSpeech() {} - public void onError(int error) {} - public void onResults(List<RecognitionResult> results, long key) {} - } - - /** - * Basic ServiceConnection which just records mService variable. - */ - public static class Connection implements ServiceConnection { - public IRecognitionService mService; - - public synchronized void onServiceConnected(ComponentName name, IBinder service) { - mService = IRecognitionService.Stub.asInterface(service); - } - - public void onServiceDisconnected(ComponentName name) { - mService = null; - } - } -} diff --git a/core/java/android/speech/RecognizerIntent.java b/core/java/android/speech/RecognizerIntent.java index ba0674475cde..49991bd7a689 100644 --- a/core/java/android/speech/RecognizerIntent.java +++ b/core/java/android/speech/RecognizerIntent.java @@ -84,6 +84,42 @@ public class RecognizerIntent { public static final String ACTION_WEB_SEARCH = "android.speech.action.WEB_SEARCH"; /** + * The minimum length of an utterance. We will not stop recording before this amount of time. + * + * Note that it is extremely rare you'd want to specify this value in an intent. If you don't + * have a very good reason to change these, you should leave them as they are. Note also that + * certain values may cause undesired or unexpected results - use judiciously! Additionally, + * depending on the recognizer implementation, these values may have no effect. + */ + public static final String EXTRA_SPEECH_INPUT_MINIMUM_LENGTH_MILLIS = + "android.speech.extras.SPEECH_INPUT_MINIMUM_LENGTH_MILLIS"; + + /** + * The amount of time that it should take after we stop hearing speech to consider the input + * complete. + * + * Note that it is extremely rare you'd want to specify this value in an intent. If + * you don't have a very good reason to change these, you should leave them as they are. Note + * also that certain values may cause undesired or unexpected results - use judiciously! + * Additionally, depending on the recognizer implementation, these values may have no effect. + */ + public static final String EXTRA_SPEECH_INPUT_COMPLETE_SILENCE_LENGTH_MILLIS = + "android.speech.extras.SPEECH_INPUT_COMPLETE_SILENCE_LENGTH_MILLIS"; + + /** + * The amount of time that it should take after we stop hearing speech to consider the input + * possibly complete. This is used to prevent the endpointer cutting off during very short + * mid-speech pauses. + * + * Note that it is extremely rare you'd want to specify this value in an intent. If + * you don't have a very good reason to change these, you should leave them as they are. Note + * also that certain values may cause undesired or unexpected results - use judiciously! + * Additionally, depending on the recognizer implementation, these values may have no effect. + */ + public static final String EXTRA_SPEECH_INPUT_POSSIBLY_COMPLETE_SILENCE_LENGTH_MILLIS = + "android.speech.extras.SPEECH_INPUT_POSSIBLY_COMPLETE_SILENCE_LENGTH_MILLIS"; + + /** * Informs the recognizer which speech model to prefer when performing * {@link #ACTION_RECOGNIZE_SPEECH}. The recognizer uses this * information to fine tune the results. This extra is required. Activities implementing @@ -111,8 +147,9 @@ public class RecognizerIntent { public static final String EXTRA_PROMPT = "android.speech.extra.PROMPT"; /** - * Optional language override to inform the recognizer that it should expect speech in - * a language different than the one set in the {@link java.util.Locale#getDefault()}. + * Optional IETF language tag (as defined by BCP 47), for example "en-US". This tag informs the + * recognizer to perform speech recognition in a language different than the one set in the + * {@link java.util.Locale#getDefault()}. */ public static final String EXTRA_LANGUAGE = "android.speech.extra.LANGUAGE"; @@ -121,7 +158,7 @@ public class RecognizerIntent { * will choose how many results to return. Must be an integer. */ public static final String EXTRA_MAX_RESULTS = "android.speech.extra.MAX_RESULTS"; - + /** * When the intent is {@link #ACTION_RECOGNIZE_SPEECH}, the speech input activity will * return results to you via the activity results mechanism. Alternatively, if you use this |