Implement SpeechRecognizerImplAndroid

content/browser/speech/speech_recognizer_impl.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/speech/speech_recognizer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/time.h"
 #include "content/browser/browser_main_loop.h"
@@ skipping 63 matching lines @@
     SpeechRecognitionEventListener* listener,
     int session_id,
     bool is_single_shot,
     SpeechRecognitionEngine* engine)
     : SpeechRecognizer(listener, session_id),
       recognition_engine_(engine),
       endpointer_(kAudioSampleRate),
       is_dispatching_event_(false),
       is_single_shot_(is_single_shot),
       state_(STATE_IDLE) {
-  DCHECK(listener_ != NULL);
+  DCHECK(this->listener() != NULL);

[bulach, 2013/06/11 07:24:48]

nit: move the DCHECK to the base class, and there just check for the param
rather than the accessor.

[janx, 2013/06/12 14:47:14]

Moved DCHECK to base class.

   DCHECK(recognition_engine_ != NULL);
   if (is_single_shot) {
     // In single shot recognition, the session is automatically ended after:
     //  - 0.5 seconds of silence if time <  3 seconds
     //  - 1   seconds of silence if time >= 3 seconds
     endpointer_.set_speech_input_complete_silence_length(
         base::Time::kMicrosecondsPerSecond / 2);
     endpointer_.set_long_speech_input_complete_silence_length(
         base::Time::kMicrosecondsPerSecond);
     endpointer_.set_long_speech_length(3 * base::Time::kMicrosecondsPerSecond);
@@ skipping 294 matching lines @@
   DCHECK(recognition_engine_.get() != NULL);
   DCHECK(!IsCapturingAudio());
   AudioManager* audio_manager = (audio_manager_for_tests_ != NULL) ?
                                  audio_manager_for_tests_ :
                                  BrowserMainLoop::GetAudioManager();
   DCHECK(audio_manager != NULL);
 
   DVLOG(1) << "SpeechRecognizerImpl starting audio capture.";
   num_samples_recorded_ = 0;
   audio_level_ = 0;
-  listener_->OnRecognitionStart(session_id_);
+  listener()->OnRecognitionStart(session_id());
 
   if (!audio_manager->HasAudioInputDevices()) {
     return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_AUDIO,
                                         SPEECH_AUDIO_ERROR_DETAILS_NO_MIC));
   }
 
   const int samples_per_packet = (kAudioSampleRate *
       recognition_engine_->GetDesiredAudioChunkDurationMs()) / 1000;
   AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
                          kAudioSampleRate, kNumBitsPerAudioSample,
@@ skipping 12 matching lines @@
   audio_controller_->Record();
   return STATE_STARTING;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::StartRecognitionEngine(const FSMEventArgs& event_args) {
   // This is the first audio packet captured, so the recognition engine is
   // started and the delegate notified about the event.
   DCHECK(recognition_engine_.get() != NULL);
   recognition_engine_->StartRecognition();
-  listener_->OnAudioStart(session_id_);
+  listener()->OnAudioStart(session_id());
 
   // This is a little hack, since TakeAudioChunk() is already called by
   // ProcessAudioPipeline(). It is the best tradeoff, unless we allow dropping
   // the first audio chunk captured after opening the audio device.
   recognition_engine_->TakeAudioChunk(*(event_args.audio_data.get()));
   return STATE_ESTIMATING_ENVIRONMENT;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::WaitEnvironmentEstimationCompletion(const FSMEventArgs&) {
   DCHECK(endpointer_.IsEstimatingEnvironment());
   if (GetElapsedTimeMs() >= kEndpointerEstimationTimeMs) {
     endpointer_.SetUserInputMode();
-    listener_->OnEnvironmentEstimationComplete(session_id_);
+    listener()->OnEnvironmentEstimationComplete(session_id());
     return STATE_WAITING_FOR_SPEECH;
   } else {
     return STATE_ESTIMATING_ENVIRONMENT;
   }
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::DetectUserSpeechOrTimeout(const FSMEventArgs&) {
   if (endpointer_.DidStartReceivingSpeech()) {
-    listener_->OnSoundStart(session_id_);
+    listener()->OnSoundStart(session_id());
     return STATE_RECOGNIZING;
   } else if (GetElapsedTimeMs() >= kNoSpeechTimeoutMs) {
     return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_NO_SPEECH));
   }
   return STATE_WAITING_FOR_SPEECH;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::DetectEndOfSpeech(const FSMEventArgs& event_args) {
   if (endpointer_.speech_input_complete())
     return StopCaptureAndWaitForResult(event_args);
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::StopCaptureAndWaitForResult(const FSMEventArgs&) {
   DCHECK(state_ >= STATE_ESTIMATING_ENVIRONMENT && state_ <= STATE_RECOGNIZING);
 
   DVLOG(1) << "Concluding recognition";
   CloseAudioControllerAsynchronously();
   recognition_engine_->AudioChunksEnded();
 
   if (state_ > STATE_WAITING_FOR_SPEECH)
-    listener_->OnSoundEnd(session_id_);
+    listener()->OnSoundEnd(session_id());
 
-  listener_->OnAudioEnd(session_id_);
+  listener()->OnAudioEnd(session_id());
   return STATE_WAITING_FINAL_RESULT;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::AbortSilently(const FSMEventArgs& event_args) {
   DCHECK_NE(event_args.event, EVENT_AUDIO_ERROR);
   DCHECK_NE(event_args.event, EVENT_ENGINE_ERROR);
   return Abort(SpeechRecognitionError(SPEECH_RECOGNITION_ERROR_NONE));
 }
 
@@ skipping 14 matching lines @@
 
   DVLOG(1) << "SpeechRecognizerImpl canceling recognition. ";
 
   // The recognition engine is initialized only after STATE_STARTING.
   if (state_ > STATE_STARTING) {
     DCHECK(recognition_engine_.get() != NULL);
     recognition_engine_->EndRecognition();
   }
 
   if (state_ > STATE_WAITING_FOR_SPEECH && state_ < STATE_WAITING_FINAL_RESULT)
-    listener_->OnSoundEnd(session_id_);
+    listener()->OnSoundEnd(session_id());
 
   if (state_ > STATE_STARTING && state_ < STATE_WAITING_FINAL_RESULT)
-    listener_->OnAudioEnd(session_id_);
+    listener()->OnAudioEnd(session_id());
 
   if (error.code != SPEECH_RECOGNITION_ERROR_NONE)
-    listener_->OnRecognitionError(session_id_, error);
+    listener()->OnRecognitionError(session_id(), error);
 
-  listener_->OnRecognitionEnd(session_id_);
+  listener()->OnRecognitionEnd(session_id());
 
   return STATE_ENDED;
 }
 
 SpeechRecognizerImpl::FSMState SpeechRecognizerImpl::ProcessIntermediateResult(
     const FSMEventArgs& event_args) {
   // Provisional results can occur only during continuous (non one-shot) mode.
   // If this check is reached it means that a continuous speech recognition
   // engine is being used for a one shot recognition.
   DCHECK_EQ(false, is_single_shot_);
 
   // In continuous recognition, intermediate results can occur even when we are
   // in the ESTIMATING_ENVIRONMENT or WAITING_FOR_SPEECH states (if the
   // recognition engine is "faster" than our endpointer). In these cases we
   // skip the endpointer and fast-forward to the RECOGNIZING state, with respect
   // of the events triggering order.
   if (state_ == STATE_ESTIMATING_ENVIRONMENT) {
     DCHECK(endpointer_.IsEstimatingEnvironment());
     endpointer_.SetUserInputMode();
-    listener_->OnEnvironmentEstimationComplete(session_id_);
+    listener()->OnEnvironmentEstimationComplete(session_id());
   } else if (state_ == STATE_WAITING_FOR_SPEECH) {
-    listener_->OnSoundStart(session_id_);
+    listener()->OnSoundStart(session_id());
   } else {
     DCHECK_EQ(STATE_RECOGNIZING, state_);
   }
 
-  listener_->OnRecognitionResults(session_id_, event_args.engine_results);
+  listener()->OnRecognitionResults(session_id(), event_args.engine_results);
   return STATE_RECOGNIZING;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::ProcessFinalResult(const FSMEventArgs& event_args) {
   const SpeechRecognitionResults& results = event_args.engine_results;
   SpeechRecognitionResults::const_iterator i = results.begin();
   bool provisional_results_pending = false;
   bool results_are_empty = true;
   for (; i != results.end(); ++i) {
     const SpeechRecognitionResult& result = *i;
     if (result.is_provisional) {
       provisional_results_pending = true;
       DCHECK(!is_single_shot_);
     } else if (results_are_empty) {
       results_are_empty = result.hypotheses.empty();
     }
   }
 
   if (provisional_results_pending) {
-    listener_->OnRecognitionResults(session_id_, results);
+    listener()->OnRecognitionResults(session_id(), results);
     // We don't end the recognition if a provisional result is received in
     // STATE_WAITING_FINAL_RESULT. A definitive result will come next and will
     // end the recognition.
     return state_;
   }
 
   recognition_engine_->EndRecognition();
 
   if (!results_are_empty) {
     // We could receive an empty result (which we won't propagate further)
     // in the following (continuous) scenario:
     //  1. The caller start pushing audio and receives some results;
     //  2. A |StopAudioCapture| is issued later;
     //  3. The final audio frames captured in the interval ]1,2] do not lead to
     //     any result (nor any error);
     //  4. The speech recognition engine, therefore, emits an empty result to
     //     notify that the recognition is ended with no error, yet neither any
     //     further result.
-    listener_->OnRecognitionResults(session_id_, results);
+    listener()->OnRecognitionResults(session_id(), results);
   }
 
-  listener_->OnRecognitionEnd(session_id_);
+  listener()->OnRecognitionEnd(session_id());
   return STATE_ENDED;
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::DoNothing(const FSMEventArgs&) const {
   return state_;  // Just keep the current state.
 }
 
 SpeechRecognizerImpl::FSMState
 SpeechRecognizerImpl::NotFeasible(const FSMEventArgs& event_args) {
@@ skipping 29 matching lines @@
   level = std::min(std::max(0.0f, level), kAudioMeterRangeMaxUnclipped);
   const float smoothing_factor = (level > audio_level_) ? kUpSmoothingFactor :
                                                           kDownSmoothingFactor;
   audio_level_ += (level - audio_level_) * smoothing_factor;
 
   float noise_level = (endpointer_.NoiseLevelDb() - kAudioMeterMinDb) /
       (kAudioMeterDbRange / kAudioMeterRangeMaxUnclipped);
   noise_level = std::min(std::max(0.0f, noise_level),
                          kAudioMeterRangeMaxUnclipped);
 
-  listener_->OnAudioLevelsChange(
-      session_id_, clip_detected ? 1.0f : audio_level_, noise_level);
+  listener()->OnAudioLevelsChange(
+      session_id(), clip_detected ? 1.0f : audio_level_, noise_level);
 }
 
 void SpeechRecognizerImpl::SetAudioManagerForTests(
     AudioManager* audio_manager) {
   audio_manager_for_tests_ = audio_manager;
 }
 
 SpeechRecognizerImpl::FSMEventArgs::FSMEventArgs(FSMEvent event_value)
     : event(event_value),
       audio_data(NULL),
       engine_error(SPEECH_RECOGNITION_ERROR_NONE) {
 }
 
 SpeechRecognizerImpl::FSMEventArgs::~FSMEventArgs() {
 }
 
 }  // namespace content