import edu.cmu.sphinx.api.SpeechResult; //导入依赖的package包/类
/**
 * Tries to predict the speech in a given audio fragment
 * @param audioStream the audio stream on which speech prediction is desired
 * @return the hypotheses of the speech in the given audio fragment
 * as a list of words
 * @throws IOException when the config does not point to correct
 * files needed for the transcription
 */
public ArrayList<WordResult> transcribe(InputStream audioStream)
        throws IOException
{
    StreamSpeechRecognizer recognizer = new StreamSpeechRecognizer(config);
    recognizer.startRecognition(audioStream);

    ArrayList<WordResult> utteredWords = new ArrayList<>();
    SpeechResult result;
    while ((result = recognizer.getResult()) != null)
    {
        utteredWords.addAll(result.getWords());
    }
    recognizer.stopRecognition();

    return utteredWords;
}
 

import edu.cmu.sphinx.api.SpeechResult; //导入依赖的package包/类
@Override
protected void onRun() {
    while (true) {
        SpeechResult result = recognizer.getResult();
        if (result != null) {
            String resultText = result.getHypothesis();
            setDescription("You said: " + resultText);
            if (!resultText.trim().isEmpty()) {
                Command nlpCommand = new Command();
                nlpCommand.setName("Natuaral language command");
                nlpCommand.setDescription("A free-form text command to be interpreded by an NLP module");
                nlpCommand.setProperty("text", resultText);
                nlpCommand.setReplyTimeout(2000);
                Command reply = notifyCommand(nlpCommand);
                if (reply != null) {
                    setDescription("No valid command similar to '" + resultText + "'");
                }
            }
        } else {
            setDescription("I can't undestand what you said");
        }
    }
}
 

import edu.cmu.sphinx.api.SpeechResult; //导入依赖的package包/类
public String hear()
{
  recognizer.startRecognition(true);
  SpeechResult result;
  String output = "";
  while((result = recognizer.getResult()) != null)
  {
    output = result.getHypothesis();
    if(output != null && !output.isEmpty() && !output.equalsIgnoreCase("<unk>"))
      break;
  }
  recognizer.stopRecognition();
  return output;
}
 

import edu.cmu.sphinx.api.SpeechResult; //导入依赖的package包/类
/**
 * Tries the predict the speech in a given audio fragment. It
 * will offer the result of every predicted word to a SynchronousQueue,
 * to be processed immediately
 * @param audioStream the audio fragment to transcribe
 * @param queue the queue to offer every WordResult to
 * @throws IOException when the config does not point to correct
 * files needed for the transcription
 */
public void transcribeSynchronous(InputStream audioStream,
                                  SynchronousQueue<WordResult> queue)
    throws IOException
{
    StreamSpeechRecognizer recognizer = new StreamSpeechRecognizer(config);
    recognizer.startRecognition(audioStream);

    logger.trace("Started chunked transcription");
    SpeechResult result;
    while( (result = recognizer.getResult()) != null)
    {
        logger.trace("got a word result of length {}",
                result.getWords().size());

        for(WordResult word : result.getWords())
        {
            logger.trace("offering {}", word.toString());
            try
            {
                queue.put(word);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }
    recognizer.stopRecognition();
}
 

import edu.cmu.sphinx.api.SpeechResult; //导入依赖的package包/类
public String getSpeechResult() {
	// Start recognition process pruning previously cached data.

	recognizer.startRecognition(true);

	String speech_text = "";
	SpeechResult result = null;

	System.out.println("Listening...");

	while ((result = recognizer.getResult()) != null) {
		speech_text = result.getHypothesis();
		String org_text = speech_text;
		speech_text = efilter.Filter(speech_text);
		System.out.println(speech_text);
		// System.out.println(cmd_classifier.PredictRawString(speech_text));
		
		System.out.println(dep_parser.getPaser(speech_text));
		System.out.println(urlgen.GetUrl(
				cmd_classifier.PredictRawString(org_text),
				speech_text,
				dep_parser.getSemanticGraph(speech_text)));

		System.out.println("Listening...");
	}

	// Pause recognition process. It can be resumed then with
	// startRecognition(false).
	recognizer.stopRecognition();

	return speech_text;

}