1 files changed, 325 insertions, 71 deletions

diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/set_global_properties_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/set_global_properties_request.cc
index 0c217b6b4f..a567d1b32f 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/set_global_properties_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/set_global_properties_request.cc
@@ -30,14 +30,15 @@
  POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "sdl_rpc_plugin/commands/mobile/set_global_properties_request.h"
 #include <string.h>
-#include <numeric>
 #include <algorithm>
-#include "sdl_rpc_plugin/commands/mobile/set_global_properties_request.h"
+#include <numeric>
 
 #include "application_manager/message_helper.h"
-#include "interfaces/MOBILE_API.h"
 #include "interfaces/HMI_API.h"
+#include "interfaces/MOBILE_API.h"
+
 #include "utils/helpers.h"
 
 namespace sdl_rpc_plugin {
@@ -45,6 +46,24 @@ using namespace application_manager;
 
 namespace commands {
 
+namespace {
+bool IsResultCodeWarning(const app_mngr::commands::ResponseInfo& first,
+                         const app_mngr::commands::ResponseInfo& second,
+                         const app_mngr::commands::ResponseInfo& third) {
+  const bool first_is_ok_second_is_warn =
+      (first.is_ok || first.is_not_used) &&
+      (hmi_apis::Common_Result::WARNINGS == second.result_code) &&
+      (hmi_apis::Common_Result::WARNINGS == third.result_code);
+
+  const bool final_warnings =
+      hmi_apis::Common_Result::WARNINGS == first.result_code &&
+      ((hmi_apis::Common_Result::WARNINGS == second.result_code) &&
+       (hmi_apis::Common_Result::WARNINGS == third.result_code));
+
+  return first_is_ok_second_is_warn || final_warnings;
+}
+}  // namespace
+
 SetGlobalPropertiesRequest::SetGlobalPropertiesRequest(
     const application_manager::commands::MessageSharedPtr& message,
     ApplicationManager& application_manager,
@@ -58,25 +77,27 @@ SetGlobalPropertiesRequest::SetGlobalPropertiesRequest(
                          policy_handler)
     , is_ui_send_(false)
     , is_tts_send_(false)
+    , is_rc_send_(false)
     , is_ui_received_(false)
     , is_tts_received_(false)
+    , is_rc_received_(false)
     , ui_result_(hmi_apis::Common_Result::INVALID_ENUM)
-    , tts_result_(hmi_apis::Common_Result::INVALID_ENUM) {}
+    , tts_result_(hmi_apis::Common_Result::INVALID_ENUM)
+    , rc_result_(hmi_apis::Common_Result::INVALID_ENUM) {}
 
 SetGlobalPropertiesRequest::~SetGlobalPropertiesRequest() {}
 
 void SetGlobalPropertiesRequest::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  const smart_objects::SmartObject& msg_params =
-      (*message_)[strings::msg_params];
+  smart_objects::SmartObject& msg_params = (*message_)[strings::msg_params];
 
   ApplicationSharedPtr app = application_manager_.application(connection_key());
 
   if (!app) {
-    LOG4CXX_ERROR(logger_,
-                  "No application associated with connection key "
-                      << connection_key());
+    LOG4CXX_ERROR(
+        logger_,
+        "No application associated with connection key " << connection_key());
     SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED);
     return;
   }
@@ -90,11 +111,9 @@ void SetGlobalPropertiesRequest::Run() {
 
   mobile_apis::Result::eType verification_result = mobile_apis::Result::SUCCESS;
 
-  if ((*message_)[strings::msg_params].keyExists(strings::menu_icon)) {
+  if (msg_params.keyExists(strings::menu_icon)) {
     verification_result = MessageHelper::VerifyImage(
-        (*message_)[strings::msg_params][strings::menu_icon],
-        app,
-        application_manager_);
+        msg_params[strings::menu_icon], app, application_manager_);
     if (mobile_apis::Result::INVALID_DATA == verification_result) {
       LOG4CXX_ERROR(
           logger_, "MessageHelper::VerifyImage return " << verification_result);
@@ -103,18 +122,29 @@ void SetGlobalPropertiesRequest::Run() {
     }
   }
   // Check for image file(s) in vrHelpItem
-  if ((*message_)[strings::msg_params].keyExists(strings::vr_help)) {
+  if (msg_params.keyExists(strings::vr_help)) {
     if (mobile_apis::Result::INVALID_DATA ==
         MessageHelper::VerifyImageVrHelpItems(
-            (*message_)[strings::msg_params][strings::vr_help],
-            app,
-            application_manager_)) {
+            msg_params[strings::vr_help], app, application_manager_)) {
       LOG4CXX_ERROR(logger_, "MessageHelper::VerifyImage return INVALID_DATA!");
       SendResponse(false, mobile_apis::Result::INVALID_DATA);
       return;
     }
   }
 
+  if (msg_params.keyExists(strings::keyboard_properties)) {
+    if (!msg_params[strings::keyboard_properties].keyExists(
+            strings::auto_complete_list) &&
+        msg_params[strings::keyboard_properties].keyExists(
+            strings::auto_complete_text)) {
+      LOG4CXX_ERROR(logger_, "Replacing deprecated autoCompleteText property");
+      msg_params[strings::keyboard_properties][strings::auto_complete_list][0] =
+          msg_params[strings::keyboard_properties][strings::auto_complete_text]
+              .asString();
+    }
+    msg_params[strings::keyboard_properties].erase(strings::auto_complete_text);
+  }
+
   if (IsWhiteSpaceExist()) {
     LOG4CXX_ERROR(logger_, "White spaces found");
     SendResponse(false, mobile_apis::Result::INVALID_DATA);
@@ -138,6 +168,19 @@ void SetGlobalPropertiesRequest::Run() {
     return;
   }
 
+  smart_objects::SmartObject params =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
+
+  if (msg_params.keyExists(strings::menu_layout)) {
+    auto menu_layout = static_cast<mobile_apis::MenuLayout::eType>(
+        msg_params[strings::menu_layout].asUInt());
+    if (app->menu_layout_supported(menu_layout)) {
+      params[strings::menu_layout] = msg_params[strings::menu_layout];
+    } else {
+      is_menu_layout_available_ = false;
+    }
+  }
+
   /* Need to set flags before sending request to HMI
    * for correct processing this flags in method on_event */
   if (is_help_prompt_present || is_timeout_prompt_present) {
@@ -154,9 +197,6 @@ void SetGlobalPropertiesRequest::Run() {
       return;
     }
 
-    smart_objects::SmartObject params =
-        smart_objects::SmartObject(smart_objects::SmartType_Map);
-
     PrepareUIRequestVRHelpData(app, msg_params, params);
     PrepareUIRequestMenuAndKeyboardData(app, msg_params, params);
 
@@ -169,9 +209,6 @@ void SetGlobalPropertiesRequest::Run() {
     LOG4CXX_DEBUG(logger_, "VRHelp params does not present");
     DCHECK_OR_RETURN_VOID(!is_vr_help_title_present && !is_vr_help_present);
 
-    smart_objects::SmartObject params =
-        smart_objects::SmartObject(smart_objects::SmartType_Map);
-
     PrepareUIRequestMenuAndKeyboardData(app, msg_params, params);
 
     // Preparing data
@@ -183,45 +220,71 @@ void SetGlobalPropertiesRequest::Run() {
     }
   }
 
+  // Check RC params
+  const bool is_user_location_present =
+      msg_params.keyExists(strings::user_location);
+  if (is_user_location_present) {
+    if (msg_params[strings::user_location].empty()) {
+      SendResponse(
+          false, mobile_apis::Result::INVALID_DATA, "UserLocation is empty");
+      return;
+    }
+    LOG4CXX_DEBUG(logger_, "Userlocation params presents");
+    const auto& user_location = msg_params[strings::user_location];
+    app->set_user_location(user_location);
+
+    auto on_global_properties_updated = [app](
+                                            plugin_manager::RPCPlugin& plugin) {
+      plugin.OnApplicationEvent(plugin_manager::kGlobalPropertiesUpdated, app);
+    };
+
+    application_manager_.GetPluginManager().ForEachPlugin(
+        on_global_properties_updated);
+
+    smart_objects::SmartObject params =
+        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    params[strings::app_id] = app->app_id();
+    params[strings::user_location] = user_location;
+    SendRCRequest(params, true);
+  }
+
   // check TTS params
   if (is_help_prompt_present || is_timeout_prompt_present) {
     LOG4CXX_DEBUG(logger_, "TTS params presents");
-    smart_objects::SmartObject params =
-        smart_objects::SmartObject(smart_objects::SmartType_Map);
+    auto tts_params = smart_objects::SmartObject(smart_objects::SmartType_Map);
 
     std::vector<std::string> invalid_params;
     if (is_help_prompt_present) {
       smart_objects::SmartObject& help_prompt =
           (*message_)[strings::msg_params][strings::help_prompt];
-      mobile_apis::Result::eType verification_result =
+      verification_result =
           MessageHelper::VerifyTtsFiles(help_prompt, app, application_manager_);
 
       if (mobile_apis::Result::FILE_NOT_FOUND == verification_result) {
-        LOG4CXX_ERROR(logger_,
-                      "MessageHelper::VerifyTtsFiles return "
-                          << verification_result);
+        LOG4CXX_ERROR(
+            logger_,
+            "MessageHelper::VerifyTtsFiles return " << verification_result);
         invalid_params.push_back("help_prompt");
       } else {
         app->set_help_prompt(help_prompt);
-        params[strings::help_prompt] = (*app->help_prompt());
+        tts_params[strings::help_prompt] = (*app->help_prompt());
       }
     }
 
     if (is_timeout_prompt_present) {
       smart_objects::SmartObject& timeout_prompt =
           (*message_)[strings::msg_params][strings::timeout_prompt];
-      mobile_apis::Result::eType verification_result =
-          MessageHelper::VerifyTtsFiles(
-              timeout_prompt, app, application_manager_);
+      verification_result = MessageHelper::VerifyTtsFiles(
+          timeout_prompt, app, application_manager_);
 
       if (mobile_apis::Result::FILE_NOT_FOUND == verification_result) {
-        LOG4CXX_ERROR(logger_,
-                      "MessageHelper::VerifyTtsFiles return "
-                          << verification_result);
+        LOG4CXX_ERROR(
+            logger_,
+            "MessageHelper::VerifyTtsFiles return " << verification_result);
         invalid_params.push_back("timeout_prompt");
       } else {
         app->set_timeout_prompt(timeout_prompt);
-        params[strings::timeout_prompt] = (*app->timeout_prompt());
+        tts_params[strings::timeout_prompt] = (*app->timeout_prompt());
       }
     }
 
@@ -239,11 +302,18 @@ void SetGlobalPropertiesRequest::Run() {
       return;
     }
 
-    params[strings::app_id] = app->app_id();
-    SendTTSRequest(params, true);
+    tts_params[strings::app_id] = app->app_id();
+    SendTTSRequest(tts_params, true);
 
     auto& help_prompt_manager = app->help_prompt_manager();
-    help_prompt_manager.OnSetGlobalPropertiesReceived(params, false);
+    help_prompt_manager.OnSetGlobalPropertiesReceived(tts_params, false);
+  } else if (!is_ui_send_ && !is_rc_send_) {
+    std::string response_info = "There are no parameters present in request.";
+    if (!is_menu_layout_available_) {
+      response_info += " The MenuLayout specified is unsupported.";
+    }
+    SendResponse(
+        false, mobile_apis::Result::INVALID_DATA, response_info.c_str());
   }
 }
 
@@ -278,7 +348,7 @@ void SetGlobalPropertiesRequest::on_event(const event_engine::Event& event) {
 
   switch (event.id()) {
     case hmi_apis::FunctionID::UI_SetGlobalProperties: {
-      LOG4CXX_INFO(logger_, "Received UI_SetGlobalProperties event");
+      LOG4CXX_DEBUG(logger_, "Received UI_SetGlobalProperties event");
       EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_UI);
       is_ui_received_ = true;
       ui_result_ = static_cast<hmi_apis::Common_Result::eType>(
@@ -291,7 +361,7 @@ void SetGlobalPropertiesRequest::on_event(const event_engine::Event& event) {
       break;
     }
     case hmi_apis::FunctionID::TTS_SetGlobalProperties: {
-      LOG4CXX_INFO(logger_, "Received TTS_SetGlobalProperties event");
+      LOG4CXX_DEBUG(logger_, "Received TTS_SetGlobalProperties event");
       EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_TTS);
       is_tts_received_ = true;
       tts_result_ = static_cast<hmi_apis::Common_Result::eType>(
@@ -303,6 +373,15 @@ void SetGlobalPropertiesRequest::on_event(const event_engine::Event& event) {
       }
       break;
     }
+    case hmi_apis::FunctionID::RC_SetGlobalProperties: {
+      LOG4CXX_DEBUG(logger_, "Received RC_SetGlobalProperties event");
+      EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_RC);
+      is_rc_received_ = true;
+      rc_result_ = static_cast<hmi_apis::Common_Result::eType>(
+          message[strings::params][hmi_response::code].asInt());
+      GetInfo(message, rc_response_info_);
+      break;
+    }
     default: {
       LOG4CXX_ERROR(logger_, "Received unknown event" << event.id());
       return;
@@ -317,10 +396,21 @@ void SetGlobalPropertiesRequest::on_event(const event_engine::Event& event) {
   std::string response_info;
   const bool result = PrepareResponseParameters(result_code, response_info);
 
-  SendResponse(result,
-               result_code,
-               response_info.empty() ? NULL : response_info.c_str(),
-               &(message[strings::msg_params]));
+  if (result && !is_menu_layout_available_) {
+    response_info =
+        "The MenuLayout specified is unsupported, the "
+        "default MenuLayout will be used." +
+        response_info;
+    SendResponse(result,
+                 mobile_apis::Result::WARNINGS,
+                 response_info.c_str(),
+                 &(message[strings::msg_params]));
+  } else {
+    SendResponse(result,
+                 result_code,
+                 response_info.empty() ? NULL : response_info.c_str(),
+                 &(message[strings::msg_params]));
+  }
 }
 
 bool SetGlobalPropertiesRequest::Init() {
@@ -338,28 +428,173 @@ bool SetGlobalPropertiesRequest::PrepareResponseParameters(
 
   app_mngr::commands::ResponseInfo tts_properties_info(
       tts_result_, HmiInterfaces::HMI_INTERFACE_TTS, application_manager_);
-  const bool result =
-      PrepareResultForMobileResponse(ui_properties_info, tts_properties_info);
+
+  app_mngr::commands::ResponseInfo rc_properties_info(
+      rc_result_, HmiInterfaces::HMI_INTERFACE_RC, application_manager_);
+
+  bool result = false;
+
+  if (!is_rc_send_) {
+    result = CommandRequestImpl::PrepareResultForMobileResponse(
+        ui_properties_info, tts_properties_info);
+  } else {
+    result = PrepareResultForMobileResponse(
+        ui_properties_info, tts_properties_info, rc_properties_info);
+  }
   if (result &&
       (HmiInterfaces::STATE_AVAILABLE == tts_properties_info.interface_state) &&
       (tts_properties_info.is_unsupported_resource)) {
     result_code = mobile_apis::Result::WARNINGS;
     tts_response_info_ = "Unsupported phoneme type sent in a prompt";
-    info = app_mngr::commands::MergeInfos(tts_properties_info,
-                                          tts_response_info_,
-                                          ui_properties_info,
-                                          ui_response_info_);
+    info = MergeInfos(tts_properties_info,
+                      tts_response_info_,
+                      ui_properties_info,
+                      ui_response_info_,
+                      rc_properties_info,
+                      rc_response_info_);
     return result;
   }
-  result_code =
-      PrepareResultCodeForResponse(ui_properties_info, tts_properties_info);
-  info = app_mngr::commands::MergeInfos(tts_properties_info,
-                                        tts_response_info_,
-                                        ui_properties_info,
-                                        ui_response_info_);
+
+  if (!is_rc_send_) {
+    result_code = CommandRequestImpl::PrepareResultCodeForResponse(
+        ui_properties_info, tts_properties_info);
+  } else {
+    result_code = PrepareResultCodeForResponse(
+        ui_properties_info, tts_properties_info, rc_properties_info);
+  }
+  info = MergeInfos(tts_properties_info,
+                    tts_response_info_,
+                    ui_properties_info,
+                    ui_response_info_,
+                    rc_properties_info,
+                    rc_response_info_);
   return result;
 }
 
+bool SetGlobalPropertiesRequest::PrepareResultForMobileResponse(
+    const app_mngr::commands::ResponseInfo& first,
+    const app_mngr::commands::ResponseInfo& second,
+    const app_mngr::commands::ResponseInfo& third) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  app_mngr::commands::ResponseInfo both_info;
+  std::vector<hmi_apis::Common_Result::eType> success_result_codes{
+      hmi_apis::Common_Result::SUCCESS,
+      hmi_apis::Common_Result::WARNINGS,
+      hmi_apis::Common_Result::WRONG_LANGUAGE,
+      hmi_apis::Common_Result::RETRY,
+      hmi_apis::Common_Result::SAVED};
+
+  both_info.is_ok =
+      helpers::in_range(success_result_codes, first.result_code) &&
+      helpers::in_range(success_result_codes, second.result_code);
+
+  both_info.is_not_used =
+      (hmi_apis::Common_Result::INVALID_ENUM == first.result_code) ||
+      (hmi_apis::Common_Result::INVALID_ENUM == second.result_code);
+
+  both_info.is_unsupported_resource =
+      (hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == first.result_code) ||
+      (hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == second.result_code);
+
+  const bool final_result = CommandRequestImpl::CheckResult(both_info, third) ||
+                            CommandRequestImpl::CheckResult(third, both_info);
+
+  return final_result;
+}
+
+mobile_apis::Result::eType
+SetGlobalPropertiesRequest::PrepareResultCodeForResponse(
+    const app_mngr::commands::ResponseInfo& first,
+    const app_mngr::commands::ResponseInfo& second,
+    const app_mngr::commands::ResponseInfo& third) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM;
+  if (IsResultCodeUnsupported(first, second, third) ||
+      IsResultCodeUnsupported(second, third, first) ||
+      IsResultCodeUnsupported(third, first, second)) {
+    return mobile_apis::Result::UNSUPPORTED_RESOURCE;
+  }
+  if (IsResultCodeWarning(first, second, third) ||
+      IsResultCodeWarning(second, third, first) ||
+      IsResultCodeWarning(third, first, second)) {
+    return mobile_apis::Result::WARNINGS;
+  }
+  // If response contains erroneous result code SDL need return erroneous
+  // result code.
+  auto first_result = hmi_apis::Common_Result::INVALID_ENUM;
+  auto second_result = hmi_apis::Common_Result::INVALID_ENUM;
+  auto third_result = hmi_apis::Common_Result::INVALID_ENUM;
+
+  if (!first.is_unsupported_resource) {
+    first_result = first.result_code;
+  }
+  if (!second.is_unsupported_resource) {
+    second_result = second.result_code;
+  }
+  if (!third.is_unsupported_resource) {
+    third_result = third.result_code;
+  }
+
+  hmi_apis::Common_Result::eType intermediate_result =
+      std::max(first_result, second_result);
+  result_code = MessageHelper::HMIToMobileResult(
+      std::max(intermediate_result, third_result));
+
+  return result_code;
+}
+
+bool SetGlobalPropertiesRequest::IsResultCodeUnsupported(
+    const application_manager::commands::ResponseInfo& first,
+    const application_manager::commands::ResponseInfo& second,
+    const application_manager::commands::ResponseInfo& third) const {
+  const bool first_ok_second_or_third_unsupported =
+      (first.is_ok || first.is_not_used) &&
+      (second.is_unsupported_resource || third.is_unsupported_resource);
+  const bool final_unsupported = first.is_unsupported_resource &&
+                                 second.is_unsupported_resource &&
+                                 third.is_unsupported_resource;
+
+  return first_ok_second_or_third_unsupported || final_unsupported;
+}
+
+std::string SetGlobalPropertiesRequest::MergeInfos(
+    const app_mngr::commands::ResponseInfo& first_info,
+    const std::string& first_str,
+    const app_mngr::commands::ResponseInfo& second_info,
+    const std::string& second_str,
+    const app_mngr::commands::ResponseInfo& third_info,
+    const std::string& third_str) {
+  if ((first_info.interface_state == HmiInterfaces::STATE_NOT_AVAILABLE) &&
+
+      ((second_info.interface_state != HmiInterfaces::STATE_NOT_AVAILABLE) &&
+       !second_str.empty()) &&
+      ((third_info.interface_state != HmiInterfaces::STATE_NOT_AVAILABLE) &&
+       !third_str.empty())) {
+    return second_str;
+  }
+
+  if ((second_info.interface_state == HmiInterfaces::STATE_NOT_AVAILABLE) &&
+      ((first_info.interface_state != HmiInterfaces::STATE_NOT_AVAILABLE) &&
+       !first_str.empty()) &&
+      ((third_info.interface_state != HmiInterfaces::STATE_NOT_AVAILABLE) &&
+       !third_str.empty())) {
+    return first_str;
+  }
+
+  if ((third_info.interface_state == HmiInterfaces::STATE_NOT_AVAILABLE) &&
+      ((first_info.interface_state != HmiInterfaces::STATE_NOT_AVAILABLE) &&
+       !first_str.empty()) &&
+      ((second_info.interface_state != HmiInterfaces::STATE_NOT_AVAILABLE) &&
+       !second_str.empty())) {
+    return third_str;
+  }
+
+  std::string intermediate_result =
+      app_mngr::commands::MergeInfos(first_str, second_str);
+  return app_mngr::commands::MergeInfos(intermediate_result, third_str);
+}
+
 void SetGlobalPropertiesRequest::PrepareUIRequestVRHelpData(
     const ApplicationSharedPtr app,
     const smart_objects::SmartObject& msg_params,
@@ -422,8 +657,19 @@ void SetGlobalPropertiesRequest::SendUIRequest(
       hmi_apis::FunctionID::UI_SetGlobalProperties, &params, use_events);
 }
 
+void SetGlobalPropertiesRequest::SendRCRequest(
+    const ns_smart_device_link::ns_smart_objects::SmartObject& params,
+    bool use_events) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  is_rc_send_ = true;
+  StartAwaitForInterface(HmiInterfaces::HMI_INTERFACE_RC);
+  SendHMIRequest(
+      hmi_apis::FunctionID::RC_SetGlobalProperties, &params, use_events);
+}
+
 bool SetGlobalPropertiesRequest::IsPendingResponseExist() {
-  return is_ui_send_ != is_ui_received_ || is_tts_send_ != is_tts_received_;
+  return is_ui_send_ != is_ui_received_ || is_tts_send_ != is_tts_received_ ||
+         is_rc_send_ != is_rc_received_;
 }
 
 bool SetGlobalPropertiesRequest::ValidateConditionalMandatoryParameters(
@@ -435,7 +681,9 @@ bool SetGlobalPropertiesRequest::ValidateConditionalMandatoryParameters(
          params.keyExists(strings::vr_help) ||
          params.keyExists(strings::menu_title) ||
          params.keyExists(strings::menu_icon) ||
-         params.keyExists(strings::keyboard_properties);
+         params.keyExists(strings::keyboard_properties) ||
+         params.keyExists(strings::menu_layout) ||
+         params.keyExists(strings::user_location);
 }
 
 bool SetGlobalPropertiesRequest::IsWhiteSpaceExist() {
@@ -531,7 +779,8 @@ bool SetGlobalPropertiesRequest::IsWhiteSpaceExist() {
             strings::limited_character_list)) {
       const smart_objects::SmartArray* lcl_array =
           msg_params[strings::keyboard_properties]
-                    [strings::limited_character_list].asArray();
+                    [strings::limited_character_list]
+                        .asArray();
 
       smart_objects::SmartArray::const_iterator it_lcl = lcl_array->begin();
       smart_objects::SmartArray::const_iterator it_lcl_end = lcl_array->end();
@@ -548,16 +797,21 @@ bool SetGlobalPropertiesRequest::IsWhiteSpaceExist() {
     }
 
     if (msg_params[strings::keyboard_properties].keyExists(
-            strings::auto_complete_text)) {
-      str =
-          msg_params[strings::keyboard_properties][strings::auto_complete_text]
-              .asCharArray();
+            strings::auto_complete_list)) {
+      const smart_objects::SmartArray* acl_array =
+          msg_params[strings::keyboard_properties][strings::auto_complete_list]
+              .asArray();
 
-      if (!CheckSyntax(str)) {
-        LOG4CXX_ERROR(logger_,
-                      "Invalid keyboard_properties "
-                      "auto_complete_text syntax check failed");
-        return true;
+      smart_objects::SmartArray::const_iterator it = acl_array->begin();
+
+      for (; it != acl_array->end(); ++it) {
+        str = it->asCharArray();
+        if (!CheckSyntax(str)) {
+          LOG4CXX_ERROR(logger_,
+                        "Invalid keyboard_properties "
+                        "auto_complete_list syntax check failed");
+          return true;
+        }
       }
     }
   }
@@ -565,4 +819,4 @@ bool SetGlobalPropertiesRequest::IsWhiteSpaceExist() {
 }
 
 }  // namespace commands
-}  // namespace application_manager
+}  // namespace sdl_rpc_plugin