android.speech.RecognizerIntent Java Examples

@Override
public void onReceive(Context context, Intent intent) {
    Bundle results = getResultExtras(true);

    if (results.containsKey(RecognizerIntent.EXTRA_LANGUAGE_PREFERENCE)) {
        languagePreference = results.getString(RecognizerIntent.EXTRA_LANGUAGE_PREFERENCE);
    }

    if (results.containsKey(RecognizerIntent.EXTRA_SUPPORTED_LANGUAGES)) {
        supportedLanguages = results.getStringArrayList(RecognizerIntent.EXTRA_SUPPORTED_LANGUAGES);

        JSONArray languages = new JSONArray(supportedLanguages);
        callbackContext.success(languages);
        return;
    }

    callbackContext.error(ERROR);
}
 

private SpeechRecognition(long nativeSpeechRecognizerImplAndroid) {
    mContinuous = false;
    mNativeSpeechRecognizerImplAndroid = nativeSpeechRecognizerImplAndroid;
    mListener = new Listener();
    mIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);

    if (sRecognitionProvider != null) {
        mRecognizer = SpeechRecognizer.createSpeechRecognizer(
                ContextUtils.getApplicationContext(), sRecognitionProvider);
    } else {
        // It is possible to force-enable the speech recognition web platform feature (using a
        // command-line flag) even if initialize() failed to find the PROVIDER_PACKAGE_NAME
        // provider, in which case the first available speech recognition provider is used.
        // Caveat: Continuous mode may not work as expected with a different provider.
        mRecognizer =
                SpeechRecognizer.createSpeechRecognizer(ContextUtils.getApplicationContext());
    }

    mRecognizer.setRecognitionListener(mListener);
}
 

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data)
{
    if (requestCode == MaterialSearchView.REQUEST_VOICE && resultCode == Activity.RESULT_OK)
    {
        ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
        if (matches != null && matches.size() > 0)
        {
            String searchWrd = matches.get(0);
            if (!TextUtils.isEmpty(searchWrd))
            {
                mSearchView.setQuery(searchWrd, false);
            }
        }
        return;
    }
    super.onActivityResult(requestCode, resultCode, data);
}
 

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if(requestCode == REQUEST_CODE && resultCode == RESULT_OK){

        /**
         * The matched text with the highest confidence score will be in position 0
         */
        ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);

        if(matches != null && matches.size() >0){
            String sentence = matches.get(0);
            speechRecognitionListener.getOnSpeechRecognitionListener()
                    .OnSpeechRecognitionFinalResult(sentence);

            return;
        }
    }

    speechRecognitionListener.onError(SpeechRecognizer.ERROR_NO_MATCH);
}
 

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data)
{
    if (requestCode == MaterialSearchView.REQUEST_VOICE && resultCode == Activity.RESULT_OK)
    {
        ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
        if (matches != null && matches.size() > 0)
        {
            String searchWrd = matches.get(0);
            if (!TextUtils.isEmpty(searchWrd))
            {
                mSearchView.setQuery(searchWrd, false);
            }
        }
        return;
    }
    super.onActivityResult(requestCode, resultCode, data);
}
 

@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
 
		switch (requestCode) {
			case RESULT_SPEECH: {
				if (resultCode == RESULT_OK && null != data) {
	 
					ArrayList<String> text = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
	 
					textView.setText(text.get(0));
					submitChat();
				}
				break;
			}
		}
//		IntentResult scanResult = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
//		if (scanResult != null) {
//			textView.setText("lookup " + scanResult.getContents());
//			submitChat();
//			if (scanResult.getContents().startsWith("http")) {
//				Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(scanResult.getContents()));
//				startActivity(intent);
//			}
//		}
	}
 

public SpeechRecognizerManager(Context context,onResultsReady listener)
{
    try{
        mListener=listener;
    }
    catch(ClassCastException e)
    {
        Log.e(TAG,e.toString());
    }
    mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
    mSpeechRecognizer = SpeechRecognizer.createSpeechRecognizer(context);
    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,
            context.getPackageName());
    startListening();

}
 

/**
 * Receiving speech input
 */
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    switch (requestCode) {
        case REQ_CODE_SPEECH_INPUT: {
            if (resultCode == Activity.RESULT_OK && null != data) {

                ArrayList<String> result = data
                        .getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
                voice_query = (result.get(0));
                Log.d("voice", voice_query);
            }
            break;
        }

    }
}
 

/**
 * Handle the results from the recognition activity.
 */
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == Activity.RESULT_OK) {
        // Fill the list view with the strings the recognizer thought it
        // could have heard
        ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);

        for (String _string : matches) {
            MLog.d(TAG, "" + _string);
        }
        onVoiceRecognitionListener.onNewResult(matches);

        //TODO disabled
    }

    if (onBluetoothListener != null) {
        onBluetoothListener.onActivityResult(requestCode, resultCode, data);
    }

    super.onActivityResult(requestCode, resultCode, data);
}
 

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
	super.onActivityResult(requestCode, resultCode, data);

	switch (requestCode) {
	case RESULT_SPEECH: {
			if (resultCode == RESULT_OK && null != data) {

				ArrayList<String> text = data
						.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);

				txtText.setText(text.get(0));
			}
		break;
	}

	}
}
 

public void promptSpeechNoteInput(View abc) {

        if (recognitionRunning) return;
        recognitionRunning = true;

        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
        // intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, "en-US"); // debug voice
        intent.putExtra(RecognizerIntent.EXTRA_PROMPT,
                getString(R.string.speak_your_note_text));

        try {
            startActivityForResult(intent, REQ_CODE_SPEECH_NOTE_INPUT);
        } catch (ActivityNotFoundException a) {
            Toast.makeText(getApplicationContext(),
                    getString(R.string.speech_recognition_is_not_supported),
                    Toast.LENGTH_LONG).show();
        }

    }
 

public void startListen() {
    _recognizer = getSpeechRecognizer();
    _recognizer.setRecognitionListener(this);
    //
    //speech recognition is supported - detect user button clicks
    //start the speech recognition intent passing required data
    Intent recognizerIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    //indicate package
    //recognizerIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, getClass().getPackage().getName());
    //message to display while listening
    recognizerIntent.putExtra(RecognizerIntent.EXTRA_PROMPT, "Your wish is my command!");
    //set speech model
    recognizerIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    //specify number of results to retrieve
    recognizerIntent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1);
    //start listening
    //startActivityForResult(listenIntent, VR_REQUEST);
    //startActivityForResult(recognizerIntent, VR_REQUEST);
    _recognizer.startListening(recognizerIntent);
}
 

protected void onVoiceClicked() {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT, VOICE_SEARCH_TEXT);
    intent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1);

    if (mActivity != null) {
        mActivity.startActivityForResult(intent, SPEECH_REQUEST_CODE);
    } else if (mFragment != null) {
        mFragment.startActivityForResult(intent, SPEECH_REQUEST_CODE);
    } else if (mSupportFragment != null) {
        mSupportFragment.startActivityForResult(intent, SPEECH_REQUEST_CODE);
    } else {
        if (mContext instanceof Activity) {
            ((Activity) mContext).startActivityForResult(intent, SPEECH_REQUEST_CODE);
        }
    }
}
 

/**
 * Showing google speech input dialog
 */
private synchronized void promptSpeechInput() {

    if (JoH.ratelimit("speech-input", 1)) {
        if (recognitionRunning) return;
        recognitionRunning = true;

        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
        // intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, "en-US"); // debug voice
        intent.putExtra(RecognizerIntent.EXTRA_PROMPT,
                getString(R.string.speak_your_treatment));

        try {
            startActivityForResult(intent, REQ_CODE_SPEECH_INPUT);
        } catch (ActivityNotFoundException a) {
            Toast.makeText(getApplicationContext(),
                    R.string.speech_recognition_is_not_supported,
                    Toast.LENGTH_LONG).show();
        }
    }
}
 

private Intent createRecognitionIntent() {
    final Intent sttIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    sttIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
            RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);

    final String language = config.getLanguage().replace('-', '_');

    sttIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, language);
    sttIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_PREFERENCE, language);
    sttIntent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
    sttIntent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, context.getPackageName());

    // WORKAROUND for https://code.google.com/p/android/issues/detail?id=75347
    sttIntent.putExtra("android.speech.extra.EXTRA_ADDITIONAL_LANGUAGES", new String[]{language});
    return sttIntent;
}
 

public void startVoiceRecognitionActivity() {

        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
        // identifying your application to the Google service
        intent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, getClass().getPackage().getName());
        // hint in the dialog
        intent.putExtra(RecognizerIntent.EXTRA_PROMPT, getString(R.string.voice_msg));
        // hint to the recognizer about what the user is going to say
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
        // number of results
        intent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 5);
        // recognition language
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
        startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);
    }
 

private void displaySpeechRecognizer() {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
            RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    // Start the activity, the intent will be populated with the speech text
    startActivityForResult(intent, SPEECH_REQUEST_CODE);
}
 

@Override
public Intent buildVoiceRecognitionIntent() {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
            RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT,
            getContext().getString(R.string.speak_now));
    return intent;
}
 

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
	if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == RESULT_OK) {
		ArrayList<String> matches = data
				.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
		mSearchView.populateEditText(matches);
	}
	super.onActivityResult(requestCode, resultCode, data);
}
 

/**
 * Determines whether or not the {@link RecognizerIntent#ACTION_WEB_SEARCH} {@link Intent}
 * is handled by any {@link android.app.Activity}s in the system.  The result will be cached for
 * future calls.  Passing {@code false} to {@code useCachedValue} will force it to re-query any
 * {@link android.app.Activity}s that can process the {@link Intent}.
 * @param context        The {@link Context} to use to check to see if the {@link Intent} will
 *                       be handled.
 * @param useCachedValue Whether or not to use the cached value from a previous result.
 * @return {@code true} if recognition is supported.  {@code false} otherwise.
 */
public static boolean isRecognitionIntentPresent(Context context, boolean useCachedValue) {
    ThreadUtils.assertOnUiThread();
    if (sHasRecognitionIntentHandler == null || !useCachedValue) {
        PackageManager pm = context.getPackageManager();
        List<ResolveInfo> activities = pm.queryIntentActivities(
                new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0);
        sHasRecognitionIntentHandler = activities.size() > 0;
    }

    return sHasRecognitionIntentHandler;
}
 

/**
 * Fire an intent to start the speech recognition activity. onActivityResult
 * is handled in BaseActivity
 */
private void startVoiceRecognitionActivity(Activity a) {

    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "Tell me something!");
    a.startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);
}
 

@CalledByNative
private void startRecognition(String language, boolean continuous, boolean interim_results) {
    if (mRecognizer == null)
        return;

    mContinuous = continuous;
    mIntent.putExtra("android.speech.extra.DICTATION_MODE", continuous);
    mIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, language);
    mIntent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, interim_results);
    mRecognizer.startListening(mIntent);
}
 

@Override
public boolean isVoiceRecognitionAvailable() {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    PackageManager mgr = getContext().getPackageManager();
    if (mgr != null) {
        List<ResolveInfo> list = mgr.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY);
        return list.size() > 0;
    }
    return false;
}
 

/** Create and initialize the recognition intent. */
private void createRecogIntent() {
  // Works without wifi, but provides many extra partial results. Respects the system language.
  recognizerIntent =
      new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH)
          .putExtra(
              RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
          .putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
}
 

/**
 * Add the intent extras
 *
 * @return the {@link Intent} with the required extras added
 */
public Intent getNativeIntent() {

    final Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
    intent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, mContext.getPackageName());
    intent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT, mContext.getString(R.string.app_name));
    intent.putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, RecognitionNative.MAX_RESULTS);
    intent.putExtra(RecognitionDefaults.PREFER_OFFLINE, SPH.getUseOffline(mContext));
    intent.putExtra(RecognitionDefaults.EXTRA_SECURE,
            (getBundle().getInt(LocalRequest.EXTRA_CONDITION, Condition.CONDITION_NONE) == Condition.CONDITION_SECURE));

    final Long timeout = SPH.getPauseTimeout(mContext);
    intent.putExtra(RecognizerIntent.EXTRA_SPEECH_INPUT_COMPLETE_SILENCE_LENGTH_MILLIS, timeout);
    intent.putExtra(RecognizerIntent.EXTRA_SPEECH_INPUT_MINIMUM_LENGTH_MILLIS, timeout);
    intent.putExtra(RecognizerIntent.EXTRA_SPEECH_INPUT_POSSIBLY_COMPLETE_SILENCE_LENGTH_MILLIS, timeout);

    if (servingRemote()) {
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, getCallback().getParcel()
                .getVRLanguageGoogle().getLocaleString());
    } else {
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, getVRLocale().toString());
    }

    return intent;
}
 

public void googleListening(View v){
	txt.setText("Status: ON");
	setMicIcon(true, false);
	Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH); 
	intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, MainActivity.voice.language);
	try {
		startActivityForResult(intent, 1);
		editTextForGoogle.setText("");
	} catch (ActivityNotFoundException a) {
		Toast t = Toast.makeText(getApplicationContext(),
				"Your device doesn't support Speech to Text",
				Toast.LENGTH_SHORT);
		t.show();
	}
}
 

/**
 * Takes and processes the results from a recognition action. It parses the confidence and
 * string values and stores the processed results here so they are made available to the
 * {@link AutocompleteController} and show up in the omnibox results. This method does not
 * reorder the voice results that come back from the recognizer.
 * @param extras The {@link Bundle} that contains the recognition results from a
 *               {@link RecognizerIntent#ACTION_RECOGNIZE_SPEECH} action.
 */
public void setVoiceResultsFromIntentBundle(Bundle extras) {
    clearVoiceSearchResults();

    if (extras == null) return;

    ArrayList<String> strings = extras.getStringArrayList(
            RecognizerIntent.EXTRA_RESULTS);
    float[] confidences = extras.getFloatArray(
            RecognizerIntent.EXTRA_CONFIDENCE_SCORES);

    if (strings == null || confidences == null) return;

    assert (strings.size() == confidences.length);
    if (strings.size() != confidences.length) return;

    for (int i = 0; i < strings.size(); ++i) {
        // Remove any spaces in the voice search match when determining whether it
        // appears to be a URL. This is to prevent cases like (
        // "tech crunch.com" and "www. engadget .com" from not appearing like URLs)
        // from not navigating to the URL.
        // If the string appears to be a URL, then use it instead of the string returned from
        // the voice engine.
        String culledString = strings.get(i).replaceAll(" ", "");
        String url = AutocompleteController.nativeQualifyPartialURLQuery(culledString);
        mResults.add(new VoiceResult(
                url == null ? strings.get(i) : culledString, confidences[i]));
    }
}
 

/**
 * Determines whether or not the {@link RecognizerIntent#ACTION_WEB_SEARCH} {@link Intent}
 * is handled by any {@link android.app.Activity}s in the system.  The result will be cached for
 * future calls.  Passing {@code false} to {@code useCachedValue} will force it to re-query any
 * {@link android.app.Activity}s that can process the {@link Intent}.
 * @param context        The {@link Context} to use to check to see if the {@link Intent} will
 *                       be handled.
 * @param useCachedValue Whether or not to use the cached value from a previous result.
 * @return {@code true} if recognition is supported.  {@code false} otherwise.
 */
public static boolean isRecognitionIntentPresent(Context context, boolean useCachedValue) {
    ThreadUtils.assertOnUiThread();
    if (sHasRecognitionIntentHandler == null || !useCachedValue) {
        PackageManager pm = context.getPackageManager();
        List<ResolveInfo> activities = pm.queryIntentActivities(
                new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0);
        sHasRecognitionIntentHandler = activities.size() > 0;
    }

    return sHasRecognitionIntentHandler;
}
 

/**
 * Receiving speech input
 */
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    switch (requestCode) {
        case REQ_CODE_SPEECH_INPUT: {
            if (resultCode == RESULT_OK && null != data) {
                ArrayList<String> result = data
                        .getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
                String results = result.get(0);
                if ((results != null) && (results.length() > 1)) {
                    if (mTextView != null) {
                        mTextView.setText(results);
                        mTextView.setVisibility(View.VISIBLE);
                    }
                    //TODO add speech recognition using the initiallexicon.txt used in Home.initializeSearchWords for Home.classifyWord called by naturalLanguageRecognition()
                    SendData(this, WEARABLE_VOICE_PAYLOAD, results.getBytes(StandardCharsets.UTF_8));
                }
                //   last_speech_time = JoH.ts();
                //  naturalLanguageRecognition(result.get(0));
            }
            recognitionRunning = false;
            break;
        }

    }
}
 

static public void startTextToSpeech(Activity context, String prompt, int requestCode) {
    Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_WEB_SEARCH);
    intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
    intent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt);
    try {
        context.startActivityForResult(intent, requestCode);
    } catch (ActivityNotFoundException a) {
        Toast.makeText(context, context.getString(R.string.speech_not_supported),
                Toast.LENGTH_SHORT).show();
    }
}