1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "chrome/browser/speech/tts_controller_impl.h"
10 #include "base/float_util.h"
11 #include "base/values.h"
12 #include "chrome/browser/browser_process.h"
13 #include "chrome/browser/speech/tts_platform.h"
16 // A value to be used to indicate that there is no char index available.
17 const int kInvalidCharIndex = -1;
19 // Given a language/region code of the form 'fr-FR', returns just the basic
20 // language portion, e.g. 'fr'.
21 std::string TrimLanguageCode(std::string lang) {
22 if (lang.size() >= 5 && lang[2] == '-')
23 return lang.substr(0, 2);
30 bool IsFinalTtsEventType(TtsEventType event_type) {
31 return (event_type == TTS_EVENT_END ||
32 event_type == TTS_EVENT_INTERRUPTED ||
33 event_type == TTS_EVENT_CANCELLED ||
34 event_type == TTS_EVENT_ERROR);
38 // UtteranceContinuousParameters
42 UtteranceContinuousParameters::UtteranceContinuousParameters()
53 VoiceData::VoiceData()
54 : gender(TTS_GENDER_NONE),
58 VoiceData::~VoiceData() {}
66 int Utterance::next_utterance_id_ = 0;
68 Utterance::Utterance(content::BrowserContext* browser_context)
69 : browser_context_(browser_context),
70 id_(next_utterance_id_++),
72 gender_(TTS_GENDER_NONE),
76 options_.reset(new base::DictionaryValue());
79 Utterance::~Utterance() {
83 void Utterance::OnTtsEvent(TtsEventType event_type,
85 const std::string& error_message) {
87 char_index_ = char_index;
88 if (IsFinalTtsEventType(event_type))
92 event_delegate_->OnTtsEvent(this, event_type, char_index, error_message);
94 event_delegate_.reset();
97 void Utterance::Finish() {
101 void Utterance::set_options(const base::Value* options) {
102 options_.reset(options->DeepCopy());
105 TtsController* TtsController::GetInstance() {
106 return TtsControllerImpl::GetInstance();
114 TtsControllerImpl* TtsControllerImpl::GetInstance() {
115 return Singleton<TtsControllerImpl>::get();
118 TtsControllerImpl::TtsControllerImpl()
119 : current_utterance_(NULL),
121 platform_impl_(NULL),
122 tts_engine_delegate_(NULL) {
125 TtsControllerImpl::~TtsControllerImpl() {
126 if (current_utterance_) {
127 current_utterance_->Finish();
128 delete current_utterance_;
131 // Clear any queued utterances too.
132 ClearUtteranceQueue(false); // Don't sent events.
135 void TtsControllerImpl::SpeakOrEnqueue(Utterance* utterance) {
136 // If we're paused and we get an utterance that can't be queued,
137 // flush the queue but stay in the paused state.
138 if (paused_ && !utterance->can_enqueue()) {
145 if (paused_ || (IsSpeaking() && utterance->can_enqueue())) {
146 utterance_queue_.push(utterance);
153 void TtsControllerImpl::SpeakNow(Utterance* utterance) {
154 // Ensure we have all built-in voices loaded. This is a no-op if already
156 bool loaded_built_in =
157 GetPlatformImpl()->LoadBuiltInTtsExtension(utterance->browser_context());
159 // Get all available voices and try to find a matching voice.
160 std::vector<VoiceData> voices;
161 GetVoices(utterance->browser_context(), &voices);
162 int index = GetMatchingVoice(utterance, voices);
166 // Select the matching voice.
167 voice = voices[index];
169 // However, if no match was found on a platform without native tts voices,
170 // attempt to get a voice based only on the current locale without respect
171 // to any supplied voice names.
172 std::vector<VoiceData> native_voices;
174 if (GetPlatformImpl()->PlatformImplAvailable())
175 GetPlatformImpl()->GetVoices(&native_voices);
177 if (native_voices.empty() && !voices.empty()) {
178 // TODO(dtseng): Notify extension caller of an error.
179 utterance->set_voice_name("");
180 // TODO(gaochun): Replace the global variable g_browser_process with
181 // GetContentClient()->browser() to eliminate the dependency of browser
182 // once TTS implementation was moved to content.
183 utterance->set_lang(g_browser_process->GetApplicationLocale());
184 index = GetMatchingVoice(utterance, voices);
186 // If even that fails, just take the first available voice.
189 voice = voices[index];
191 // Otherwise, simply give native voices a chance to handle this utterance.
196 GetPlatformImpl()->WillSpeakUtteranceWithVoice(utterance, voice);
199 #if !defined(OS_ANDROID)
200 DCHECK(!voice.extension_id.empty());
201 current_utterance_ = utterance;
202 utterance->set_extension_id(voice.extension_id);
203 if (tts_engine_delegate_)
204 tts_engine_delegate_->Speak(utterance, voice);
205 bool sends_end_event =
206 voice.events.find(TTS_EVENT_END) != voice.events.end();
207 if (!sends_end_event) {
210 current_utterance_ = NULL;
211 SpeakNextUtterance();
215 // It's possible for certain platforms to send start events immediately
217 current_utterance_ = utterance;
218 GetPlatformImpl()->clear_error();
219 bool success = GetPlatformImpl()->Speak(
224 utterance->continuous_parameters());
226 current_utterance_ = NULL;
228 // If the native voice wasn't able to process this speech, see if
229 // the browser has built-in TTS that isn't loaded yet.
230 if (!success && loaded_built_in) {
231 utterance_queue_.push(utterance);
236 utterance->OnTtsEvent(TTS_EVENT_ERROR, kInvalidCharIndex,
237 GetPlatformImpl()->error());
244 void TtsControllerImpl::Stop() {
246 if (current_utterance_ && !current_utterance_->extension_id().empty()) {
247 #if !defined(OS_ANDROID)
248 if (tts_engine_delegate_)
249 tts_engine_delegate_->Stop(current_utterance_);
252 GetPlatformImpl()->clear_error();
253 GetPlatformImpl()->StopSpeaking();
256 if (current_utterance_)
257 current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
259 FinishCurrentUtterance();
260 ClearUtteranceQueue(true); // Send events.
263 void TtsControllerImpl::Pause() {
265 if (current_utterance_ && !current_utterance_->extension_id().empty()) {
266 #if !defined(OS_ANDROID)
267 if (tts_engine_delegate_)
268 tts_engine_delegate_->Pause(current_utterance_);
270 } else if (current_utterance_) {
271 GetPlatformImpl()->clear_error();
272 GetPlatformImpl()->Pause();
276 void TtsControllerImpl::Resume() {
278 if (current_utterance_ && !current_utterance_->extension_id().empty()) {
279 #if !defined(OS_ANDROID)
280 if (tts_engine_delegate_)
281 tts_engine_delegate_->Resume(current_utterance_);
283 } else if (current_utterance_) {
284 GetPlatformImpl()->clear_error();
285 GetPlatformImpl()->Resume();
287 SpeakNextUtterance();
291 void TtsControllerImpl::OnTtsEvent(int utterance_id,
292 TtsEventType event_type,
294 const std::string& error_message) {
295 // We may sometimes receive completion callbacks "late", after we've
296 // already finished the utterance (for example because another utterance
297 // interrupted or we got a call to Stop). This is normal and we can
298 // safely just ignore these events.
299 if (!current_utterance_ || utterance_id != current_utterance_->id()) {
302 current_utterance_->OnTtsEvent(event_type, char_index, error_message);
303 if (current_utterance_->finished()) {
304 FinishCurrentUtterance();
305 SpeakNextUtterance();
309 void TtsControllerImpl::GetVoices(content::BrowserContext* browser_context,
310 std::vector<VoiceData>* out_voices) {
311 #if !defined(OS_ANDROID)
312 if (browser_context && tts_engine_delegate_)
313 tts_engine_delegate_->GetVoices(browser_context, out_voices);
316 TtsPlatformImpl* platform_impl = GetPlatformImpl();
318 // Ensure we have all built-in voices loaded. This is a no-op if already
320 platform_impl->LoadBuiltInTtsExtension(browser_context);
321 if (platform_impl->PlatformImplAvailable())
322 platform_impl->GetVoices(out_voices);
326 bool TtsControllerImpl::IsSpeaking() {
327 return current_utterance_ != NULL || GetPlatformImpl()->IsSpeaking();
330 void TtsControllerImpl::FinishCurrentUtterance() {
331 if (current_utterance_) {
332 if (!current_utterance_->finished())
333 current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
335 delete current_utterance_;
336 current_utterance_ = NULL;
340 void TtsControllerImpl::SpeakNextUtterance() {
344 // Start speaking the next utterance in the queue. Keep trying in case
345 // one fails but there are still more in the queue to try.
346 while (!utterance_queue_.empty() && !current_utterance_) {
347 Utterance* utterance = utterance_queue_.front();
348 utterance_queue_.pop();
353 void TtsControllerImpl::ClearUtteranceQueue(bool send_events) {
354 while (!utterance_queue_.empty()) {
355 Utterance* utterance = utterance_queue_.front();
356 utterance_queue_.pop();
358 utterance->OnTtsEvent(TTS_EVENT_CANCELLED, kInvalidCharIndex,
366 void TtsControllerImpl::SetPlatformImpl(
367 TtsPlatformImpl* platform_impl) {
368 platform_impl_ = platform_impl;
371 int TtsControllerImpl::QueueSize() {
372 return static_cast<int>(utterance_queue_.size());
375 TtsPlatformImpl* TtsControllerImpl::GetPlatformImpl() {
377 platform_impl_ = TtsPlatformImpl::GetInstance();
378 return platform_impl_;
381 int TtsControllerImpl::GetMatchingVoice(
382 const Utterance* utterance, std::vector<VoiceData>& voices) {
383 // Make two passes: the first time, do strict language matching
384 // ('fr-FR' does not match 'fr-CA'). The second time, do prefix
385 // language matching ('fr-FR' matches 'fr' and 'fr-CA')
386 for (int pass = 0; pass < 2; ++pass) {
387 for (size_t i = 0; i < voices.size(); ++i) {
388 const VoiceData& voice = voices[i];
390 if (!utterance->extension_id().empty() &&
391 utterance->extension_id() != voice.extension_id) {
395 if (!voice.name.empty() &&
396 !utterance->voice_name().empty() &&
397 voice.name != utterance->voice_name()) {
400 if (!voice.lang.empty() && !utterance->lang().empty()) {
401 std::string voice_lang = voice.lang;
402 std::string utterance_lang = utterance->lang();
404 voice_lang = TrimLanguageCode(voice_lang);
405 utterance_lang = TrimLanguageCode(utterance_lang);
407 if (voice_lang != utterance_lang) {
411 if (voice.gender != TTS_GENDER_NONE &&
412 utterance->gender() != TTS_GENDER_NONE &&
413 voice.gender != utterance->gender()) {
417 if (utterance->required_event_types().size() > 0) {
418 bool has_all_required_event_types = true;
419 for (std::set<TtsEventType>::const_iterator iter =
420 utterance->required_event_types().begin();
421 iter != utterance->required_event_types().end();
423 if (voice.events.find(*iter) == voice.events.end()) {
424 has_all_required_event_types = false;
428 if (!has_all_required_event_types)
432 return static_cast<int>(i);
439 void TtsControllerImpl::VoicesChanged() {
440 for (std::set<VoicesChangedDelegate*>::iterator iter =
441 voices_changed_delegates_.begin();
442 iter != voices_changed_delegates_.end(); ++iter) {
443 (*iter)->OnVoicesChanged();
447 void TtsControllerImpl::AddVoicesChangedDelegate(
448 VoicesChangedDelegate* delegate) {
449 voices_changed_delegates_.insert(delegate);
452 void TtsControllerImpl::RemoveVoicesChangedDelegate(
453 VoicesChangedDelegate* delegate) {
454 voices_changed_delegates_.erase(delegate);
457 void TtsControllerImpl::SetTtsEngineDelegate(
458 TtsEngineDelegate* delegate) {
459 tts_engine_delegate_ = delegate;
462 TtsEngineDelegate* TtsControllerImpl::GetTtsEngineDelegate() {
463 return tts_engine_delegate_;