1 files changed, 120 insertions, 73 deletions

diff --git a/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc b/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc
index b1ac31b9d8..d595119d45 100644
--- a/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc
+++ b/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc
@@ -33,9 +33,10 @@
 
 #include <cstring>
 #include "application_manager/commands/mobile/perform_audio_pass_thru_request.h"
-#include "application_manager/application_manager_impl.h"
+
 #include "application_manager/application_impl.h"
 #include "application_manager/message_helper.h"
+#include "utils/helpers.h"
 
 namespace application_manager {
 
@@ -44,25 +45,19 @@ namespace commands {
 namespace str = strings;
 
 PerformAudioPassThruRequest::PerformAudioPassThruRequest(
-    const MessageSharedPtr& message)
-    : CommandRequestImpl(message),
-      is_active_tts_speak_(false),
-      result_tts_speak_(mobile_apis::Result::SUCCESS) {
+    const MessageSharedPtr& message, ApplicationManager& application_manager)
+    : CommandRequestImpl(message, application_manager)
+    , is_active_tts_speak_(false)
+    , result_tts_speak_(mobile_apis::Result::SUCCESS) {
   subscribe_on_event(hmi_apis::FunctionID::TTS_OnResetTimeout);
 }
 
-PerformAudioPassThruRequest::~PerformAudioPassThruRequest() {
-}
+PerformAudioPassThruRequest::~PerformAudioPassThruRequest() {}
 
 void PerformAudioPassThruRequest::onTimeOut() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  if (ApplicationManagerImpl::instance()->end_audio_pass_thru()) {
-    ApplicationManagerImpl::instance()->StopAudioPassThru(connection_key());
-  }
-
   FinishTTSSpeak();
-
   CommandRequestImpl::onTimeOut();
 }
 
@@ -75,8 +70,7 @@ bool PerformAudioPassThruRequest::Init() {
 void PerformAudioPassThruRequest::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  ApplicationSharedPtr app =
-      ApplicationManagerImpl::instance()->application(connection_key());
+  ApplicationSharedPtr app = application_manager_.application(connection_key());
 
   if (!app) {
     LOG4CXX_ERROR(logger_, "APPLICATION_NOT_REGISTERED");
@@ -92,7 +86,8 @@ void PerformAudioPassThruRequest::Run() {
 
   if (IsWhiteSpaceExist()) {
     LOG4CXX_ERROR(logger_,
-                  "Incoming perform audio pass thru has contains \\t\\n \\\\t \\\\n"
+                  "Incoming perform audio pass thru has contains "
+                  "\\t\\n \\\\t \\\\n"
                   " text contains only whitespace in initialPrompt");
     SendResponse(false, mobile_apis::Result::INVALID_DATA);
     return;
@@ -112,10 +107,18 @@ void PerformAudioPassThruRequest::Run() {
 
 void PerformAudioPassThruRequest::on_event(const event_engine::Event& event) {
   LOG4CXX_AUTO_TRACE(logger_);
+  using namespace helpers;
+
   const smart_objects::SmartObject& message = event.smart_object();
 
   switch (event.id()) {
     case hmi_apis::FunctionID::UI_PerformAudioPassThru: {
+      LOG4CXX_TRACE(logger_, "Received UI_PerformAudioPassThru");
+
+      if (!WaitTTSSpeak()) {
+        LOG4CXX_DEBUG(logger_, "TTS.Speak is absent");
+        return;
+      }
 
       mobile_apis::Result::eType mobile_code =
           GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
@@ -128,47 +131,52 @@ void PerformAudioPassThruRequest::on_event(const event_engine::Event& event) {
         return;
       }
 
-      if (ApplicationManagerImpl::instance()->end_audio_pass_thru()) {
-        ApplicationManagerImpl::instance()->StopAudioPassThru(connection_key());
-      }
-
       FinishTTSSpeak();
 
       std::string return_info;
-      bool result = mobile_apis::Result::SUCCESS == mobile_code ||
-                          mobile_apis::Result::RETRY == mobile_code;
-
-      if ((mobile_apis::Result::SUCCESS == mobile_code) &&
-          (mobile_apis::Result::UNSUPPORTED_RESOURCE == result_tts_speak_)) {
+      const bool result = Compare<mobile_api::Result::eType, EQ, ONE>(
+          mobile_code,
+          mobile_apis::Result::SUCCESS,
+          mobile_apis::Result::RETRY,
+          mobile_apis::Result::WARNINGS);
+
+      const bool is_result_ok = Compare<mobile_api::Result::eType, EQ, ONE>(
+          mobile_code,
+          mobile_apis::Result::SUCCESS,
+          mobile_apis::Result::WARNINGS);
+
+      if (is_result_ok &&
+          mobile_apis::Result::UNSUPPORTED_RESOURCE == result_tts_speak_) {
         mobile_code = mobile_apis::Result::WARNINGS;
         return_info = "Unsupported phoneme type sent in a prompt";
       }
 
-      SendResponse(result, mobile_code, return_info.c_str(),
+      SendResponse(result,
+                   mobile_code,
+                   return_info.empty() ? NULL : return_info.c_str(),
                    &(message[strings::msg_params]));
       break;
     }
     case hmi_apis::FunctionID::TTS_Speak: {
       LOG4CXX_INFO(logger_, "Received TTS_Speak event");
-      result_tts_speak_ = GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
-          message[strings::params][hmi_response::code].asUInt()));
+      result_tts_speak_ =
+          GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
+              message[strings::params][hmi_response::code].asUInt()));
       is_active_tts_speak_ = false;
       if (mobile_apis::Result::SUCCESS == result_tts_speak_) {
         SendRecordStartNotification();
         StartMicrophoneRecording();
 
         // update request timeout to get time for perform audio recording
-        ApplicationManagerImpl::instance()->
-            updateRequestTimeout(connection_key(),
-                                 correlation_id(),
-                                 default_timeout());
+        application_manager_.updateRequestTimeout(
+            connection_key(), correlation_id(), default_timeout());
       }
       break;
     }
     case hmi_apis::FunctionID::TTS_OnResetTimeout: {
       LOG4CXX_INFO(logger_, "Received TTS_OnResetTimeout event");
 
-      ApplicationManagerImpl::instance()->updateRequestTimeout(
+      application_manager_.updateRequestTimeout(
           connection_key(), correlation_id(), default_timeout());
       break;
     }
@@ -180,7 +188,8 @@ void PerformAudioPassThruRequest::on_event(const event_engine::Event& event) {
 }
 
 void PerformAudioPassThruRequest::SendSpeakRequest() {
-  // crate HMI TTS speak request
+  LOG4CXX_AUTO_TRACE(logger_);
+
   using namespace hmi_apis;
   using namespace smart_objects;
 
@@ -189,8 +198,8 @@ void PerformAudioPassThruRequest::SendSpeakRequest() {
   if ((*message_)[str::msg_params].keyExists(str::initial_prompt) &&
       (0 < (*message_)[str::msg_params][str::initial_prompt].length())) {
     for (uint32_t i = 0;
-        i < (*message_)[str::msg_params][str::initial_prompt].length();
-        ++i) {
+         i < (*message_)[str::msg_params][str::initial_prompt].length();
+         ++i) {
       msg_params[hmi_request::tts_chunks][i][str::text] =
           (*message_)[str::msg_params][str::initial_prompt][i][str::text];
       msg_params[hmi_request::tts_chunks][i][str::type] =
@@ -205,12 +214,13 @@ void PerformAudioPassThruRequest::SendSpeakRequest() {
 }
 
 void PerformAudioPassThruRequest::SendPerformAudioPassThruRequest() {
-  smart_objects::SmartObject msg_params = smart_objects::SmartObject(
-      smart_objects::SmartType_Map);
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  smart_objects::SmartObject msg_params =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
 
   msg_params[str::app_id] = connection_key();
 
-  // duration
   msg_params[hmi_request::max_duration] =
       (*message_)[str::msg_params][str::max_duration];
 
@@ -218,21 +228,21 @@ void PerformAudioPassThruRequest::SendPerformAudioPassThruRequest() {
       smart_objects::SmartObject(smart_objects::SmartType_Array);
 
   if ((*message_)[str::msg_params].keyExists(str::audio_pass_display_text1)) {
-    msg_params[hmi_request::audio_pass_display_texts]
-               [0][hmi_request::field_name] = static_cast<int32_t>
-    (hmi_apis::Common_TextFieldName::audioPassThruDisplayText1);
-    msg_params[hmi_request::audio_pass_display_texts]
-               [0][hmi_request::field_text] =
-        (*message_)[str::msg_params][str::audio_pass_display_text1];
+    msg_params[hmi_request::audio_pass_display_texts][0]
+              [hmi_request::field_name] = static_cast<int32_t>(
+                  hmi_apis::Common_TextFieldName::audioPassThruDisplayText1);
+    msg_params[hmi_request::audio_pass_display_texts][0]
+              [hmi_request::field_text] =
+                  (*message_)[str::msg_params][str::audio_pass_display_text1];
   }
 
   if ((*message_)[str::msg_params].keyExists(str::audio_pass_display_text2)) {
-    msg_params[hmi_request::audio_pass_display_texts]
-               [1][hmi_request::field_name] = static_cast<int32_t>
-    (hmi_apis::Common_TextFieldName::audioPassThruDisplayText2);
-    msg_params[hmi_request::audio_pass_display_texts]
-               [1][hmi_request::field_text] =
-        (*message_)[str::msg_params][str::audio_pass_display_text2];
+    msg_params[hmi_request::audio_pass_display_texts][1]
+              [hmi_request::field_name] = static_cast<int32_t>(
+                  hmi_apis::Common_TextFieldName::audioPassThruDisplayText2);
+    msg_params[hmi_request::audio_pass_display_texts][1]
+              [hmi_request::field_text] =
+                  (*message_)[str::msg_params][str::audio_pass_display_text2];
   }
 
   if ((*message_)[str::msg_params].keyExists(str::mute_audio)) {
@@ -243,23 +253,28 @@ void PerformAudioPassThruRequest::SendPerformAudioPassThruRequest() {
     msg_params[str::mute_audio] = true;
   }
 
-  SendHMIRequest(hmi_apis::FunctionID::UI_PerformAudioPassThru,
-                 &msg_params, true);
+  SendHMIRequest(
+      hmi_apis::FunctionID::UI_PerformAudioPassThru, &msg_params, true);
 }
 
 void PerformAudioPassThruRequest::SendRecordStartNotification() {
-  smart_objects::SmartObject msg_params = smart_objects::SmartObject(
-      smart_objects::SmartType_Map);
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  smart_objects::SmartObject msg_params =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
   msg_params[strings::app_id] = connection_key();
 
   CreateHMINotification(hmi_apis::FunctionID::UI_OnRecordStart, msg_params);
 }
 
 void PerformAudioPassThruRequest::StartMicrophoneRecording() {
-  ApplicationManagerImpl::instance()->begin_audio_pass_thru();
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  application_manager_.BeginAudioPassThrough();
 
-  ApplicationManagerImpl::instance()->StartAudioPassThruThread(
-      connection_key(), correlation_id(),
+  application_manager_.StartAudioPassThruThread(
+      connection_key(),
+      correlation_id(),
       (*message_)[str::msg_params][str::max_duration].asInt(),
       (*message_)[str::msg_params][str::sampling_rate].asInt(),
       (*message_)[str::msg_params][str::bits_per_sample].asInt(),
@@ -286,25 +301,25 @@ bool PerformAudioPassThruRequest::IsWhiteSpaceExist() {
     }
   }
 
-  if ((*message_)[strings::msg_params].
-      keyExists(strings::audio_pass_display_text1)) {
-
-    str = (*message_)[strings::msg_params]
-                     [strings::audio_pass_display_text1].asCharArray();
+  if ((*message_)[strings::msg_params].keyExists(
+          strings::audio_pass_display_text1)) {
+    str = (*message_)[strings::msg_params][strings::audio_pass_display_text1]
+              .asCharArray();
     if (!CheckSyntax(str)) {
-      LOG4CXX_ERROR(logger_,
+      LOG4CXX_ERROR(
+          logger_,
           "Invalid audio_pass_display_text1 value syntax check failed");
       return true;
     }
   }
 
-  if ((*message_)[strings::msg_params].
-      keyExists(strings::audio_pass_display_text2)) {
-
-    str = (*message_)[strings::msg_params]
-                     [strings::audio_pass_display_text2].asCharArray();
+  if ((*message_)[strings::msg_params].keyExists(
+          strings::audio_pass_display_text2)) {
+    str = (*message_)[strings::msg_params][strings::audio_pass_display_text2]
+              .asCharArray();
     if (!CheckSyntax(str)) {
-      LOG4CXX_ERROR(logger_,
+      LOG4CXX_ERROR(
+          logger_,
           "Invalid audio_pass_display_text2 value syntax check failed");
       return true;
     }
@@ -312,11 +327,43 @@ bool PerformAudioPassThruRequest::IsWhiteSpaceExist() {
   return false;
 }
 
-void PerformAudioPassThruRequest::FinishTTSSpeak(){
-  if (is_active_tts_speak_) {
-    is_active_tts_speak_ = false;
-    SendHMIRequest(hmi_apis::FunctionID::TTS_StopSpeaking, NULL);
+void PerformAudioPassThruRequest::FinishTTSSpeak() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (application_manager_.EndAudioPassThrough()) {
+    LOG4CXX_DEBUG(logger_, "Stop AudioPassThru.");
+    application_manager_.StopAudioPassThru(connection_key());
   }
+  if (!is_active_tts_speak_) {
+    LOG4CXX_WARN(logger_, "TTS Speak is inactive.");
+    return;
+  }
+  is_active_tts_speak_ = false;
+  SendHMIRequest(hmi_apis::FunctionID::TTS_StopSpeaking, NULL);
+}
+
+bool PerformAudioPassThruRequest::WaitTTSSpeak() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  uint64_t default_timeout_msec =
+      application_manager_.get_settings().default_timeout();
+  const TimevalStruct start_time = date_time::DateTime::getCurrentTime();
+
+  // Waiting for TTS_Speak
+  while (is_active_tts_speak_) {
+    uint64_t difference_between_start_current_time =
+        date_time::DateTime::calculateTimeSpan(start_time);
+    // Send GENERIC_ERROR after default timeout
+    if (difference_between_start_current_time > default_timeout_msec) {
+      LOG4CXX_WARN(logger_, "Expired timeout for TTS.Speak response");
+      // Don't use onTimeOut(), because default_timeout_ is bigger than
+      // Default time in *.ini file
+      FinishTTSSpeak();
+      SendResponse(false,
+                   mobile_apis::Result::eType::GENERIC_ERROR,
+                   "Expired timeout for TTS.Speak response");
+      return false;
+    }
+  }
+  return true;
 }
 
 }  // namespace commands