Add SubtleAlert RPC (#3459)

* Add SubtleAlert RPC to project

* Add OnSubtleAlertPressed implementation

* Add `subtle_notifications_per_minute_by_priority` field to policies

10 files changed, 820 insertions, 3 deletions

diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_ui_subtle_alert_pressed_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_ui_subtle_alert_pressed_notification.cc
new file mode 100644
index 0000000000..b2f5f80055
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/on_ui_subtle_alert_pressed_notification.cc
@@ -0,0 +1,63 @@
+/*
+ Copyright (c) 2020, Ford Motor Company, Livio
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with the
+ distribution.
+
+ Neither the name of the the copyright holders nor the names of their
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sdl_rpc_plugin/commands/hmi/on_ui_subtle_alert_pressed_notification.h"
+
+namespace sdl_rpc_plugin {
+using namespace application_manager;
+
+namespace commands {
+
+OnUISubtleAlertPressedNotification::OnUISubtleAlertPressedNotification(
+    const application_manager::commands::MessageSharedPtr& message,
+    ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler)
+    : NotificationFromHMI(message,
+                          application_manager,
+                          rpc_service,
+                          hmi_capabilities,
+                          policy_handler) {}
+
+OnUISubtleAlertPressedNotification::~OnUISubtleAlertPressedNotification() {}
+
+void OnUISubtleAlertPressedNotification::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  (*message_)[strings::params][strings::function_id] = static_cast<int32_t>(
+      mobile_apis::FunctionID::eType::OnSubtleAlertPressedID);
+  SendNotificationToMobile(message_);
+}
+
+}  // namespace commands
+}  // namespace sdl_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/ui_subtle_alert_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/ui_subtle_alert_request.cc
new file mode 100644
index 0000000000..02e9af4c3c
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/ui_subtle_alert_request.cc
@@ -0,0 +1,69 @@
+/*
+ Copyright (c) 2020, Ford Motor Company, Livio
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with the
+ distribution.
+
+ Neither the name of the the copyright holders nor the names of their
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sdl_rpc_plugin/commands/hmi/ui_subtle_alert_request.h"
+
+namespace sdl_rpc_plugin {
+using namespace application_manager;
+
+namespace commands {
+
+UISubtleAlertRequest::UISubtleAlertRequest(
+    const application_manager::commands::MessageSharedPtr& message,
+    ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler)
+    : RequestToHMI(message,
+                   application_manager,
+                   rpc_service,
+                   hmi_capabilities,
+                   policy_handler) {
+  const auto& msg_params = (*message_)[strings::msg_params];
+  if (msg_params.keyExists(strings::duration)) {
+    uint32_t request_timeout = msg_params[strings::duration].asUInt();
+    default_timeout_ += request_timeout;
+  } else {
+    default_timeout_ = 0;
+  }
+}
+
+UISubtleAlertRequest::~UISubtleAlertRequest() {}
+
+void UISubtleAlertRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  SendRequest();
+}
+
+}  // namespace commands
+}  // namespace sdl_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/ui_subtle_alert_response.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/ui_subtle_alert_response.cc
new file mode 100644
index 0000000000..51e9802db7
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/hmi/ui_subtle_alert_response.cc
@@ -0,0 +1,63 @@
+/*
+ Copyright (c) 2020, Ford Motor Company, Livio
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with the
+ distribution.
+
+ Neither the name of the the copyright holders nor the names of their
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sdl_rpc_plugin/commands/hmi/ui_subtle_alert_response.h"
+
+namespace sdl_rpc_plugin {
+using namespace application_manager;
+
+namespace commands {
+
+UISubtleAlertResponse::UISubtleAlertResponse(
+    const application_manager::commands::MessageSharedPtr& message,
+    ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler)
+    : ResponseFromHMI(message,
+                      application_manager,
+                      rpc_service,
+                      hmi_capabilities,
+                      policy_handler) {}
+
+UISubtleAlertResponse::~UISubtleAlertResponse() {}
+
+void UISubtleAlertResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  event_engine::Event event(hmi_apis::FunctionID::UI_SubtleAlert);
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+}  // namespace commands
+}  // namespace sdl_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/alert_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/alert_request.cc
index 57912e7087..a0544ee444 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/alert_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/alert_request.cc
@@ -61,7 +61,6 @@ AlertRequest::AlertRequest(
     , awaiting_ui_alert_response_(false)
     , awaiting_tts_speak_response_(false)
     , awaiting_tts_stop_speaking_response_(false)
-    , is_alert_succeeded_(false)
     , is_ui_alert_sent_(false)
     , alert_result_(hmi_apis::Common_Result::INVALID_ENUM)
     , tts_speak_result_(hmi_apis::Common_Result::INVALID_ENUM) {
@@ -258,7 +257,7 @@ bool AlertRequest::Validate(uint32_t app_id) {
     return false;
   }
 
-  if (!CheckStringsOfAlertRequest()) {
+  if (!CheckStrings()) {
     SendResponse(false, mobile_apis::Result::INVALID_DATA);
     return false;
   }
@@ -423,7 +422,7 @@ void AlertRequest::SendSpeakRequest(int32_t app_id,
   SendHMIRequest(FunctionID::TTS_Speak, &msg_params, true);
 }
 
-bool AlertRequest::CheckStringsOfAlertRequest() {
+bool AlertRequest::CheckStrings() {
   LOG4CXX_AUTO_TRACE(logger_);
   const char* str = NULL;
 
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/cancel_interaction_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/cancel_interaction_request.cc
index 82e0703da1..6873cb7bf1 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/cancel_interaction_request.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/cancel_interaction_request.cc
@@ -66,6 +66,7 @@ void CancelInteractionRequest::Run() {
               function_id,
               mobile_apis::FunctionID::PerformInteractionID,
               mobile_apis::FunctionID::AlertID,
+              mobile_apis::FunctionID::SubtleAlertID,
               mobile_apis::FunctionID::ScrollableMessageID,
               mobile_apis::FunctionID::SliderID)) {
     LOG4CXX_ERROR(logger_, "Bad function ID" << function_id);
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_subtle_alert_pressed_notification.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_subtle_alert_pressed_notification.cc
new file mode 100644
index 0000000000..ce1d1b16d1
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/on_subtle_alert_pressed_notification.cc
@@ -0,0 +1,74 @@
+/*
+ Copyright (c) 2020, Ford Motor Company, Livio
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with the
+ distribution.
+
+ Neither the name of the the copyright holders nor the names of their
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sdl_rpc_plugin/commands/mobile/on_subtle_alert_pressed_notification.h"
+#include "application_manager/application_impl.h"
+
+namespace sdl_rpc_plugin {
+using namespace application_manager;
+
+namespace commands {
+
+OnSubtleAlertPressedNotification::OnSubtleAlertPressedNotification(
+    const application_manager::commands::MessageSharedPtr& message,
+    ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler)
+    : CommandNotificationImpl(message,
+                              application_manager,
+                              rpc_service,
+                              hmi_capabilities,
+                              policy_handler) {}
+
+OnSubtleAlertPressedNotification::~OnSubtleAlertPressedNotification() {}
+
+void OnSubtleAlertPressedNotification::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  ApplicationSharedPtr app = application_manager_.application(
+      (*message_)[strings::msg_params][strings::app_id].asInt());
+
+  if (!app) {
+    LOG4CXX_ERROR(logger_, "No application associated with session key");
+    return;
+  }
+
+  (*message_)[strings::params][strings::connection_key] = app->app_id();
+  // remove app_id from notification
+  (*message_)[strings::msg_params].erase(strings::app_id);
+
+  SendNotification();
+}
+
+}  // namespace commands
+}  // namespace sdl_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/subtle_alert_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/subtle_alert_request.cc
new file mode 100644
index 0000000000..23604a6b93
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/subtle_alert_request.cc
@@ -0,0 +1,461 @@
+/*
+ Copyright (c) 2020, Ford Motor Company, Livio
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with the
+ distribution.
+
+ Neither the name of the the copyright holders nor the names of their
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sdl_rpc_plugin/commands/mobile/subtle_alert_request.h"
+
+#include "application_manager/application_impl.h"
+#include "application_manager/message_helper.h"
+
+namespace sdl_rpc_plugin {
+using namespace application_manager;
+
+namespace commands {
+
+SubtleAlertRequest::SubtleAlertRequest(
+    const application_manager::commands::MessageSharedPtr& message,
+    ApplicationManager& application_manager,
+    rpc_service::RPCService& rpc_service,
+    HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler)
+    : CommandRequestImpl(message,
+                         application_manager,
+                         rpc_service,
+                         hmi_capabilities,
+                         policy_handler)
+    , awaiting_ui_subtle_alert_response_(false)
+    , awaiting_tts_speak_response_(false)
+    , awaiting_tts_stop_speaking_response_(false)
+    , is_ui_subtle_alert_sent_(false)
+    , is_tts_stop_speaking_sent_(false)
+    , subtle_alert_result_(hmi_apis::Common_Result::INVALID_ENUM)
+    , tts_speak_result_(hmi_apis::Common_Result::INVALID_ENUM) {
+  subscribe_on_event(hmi_apis::FunctionID::UI_OnResetTimeout);
+  subscribe_on_event(hmi_apis::FunctionID::TTS_OnResetTimeout);
+}
+
+SubtleAlertRequest::~SubtleAlertRequest() {}
+
+bool SubtleAlertRequest::Init() {
+  /* Timeout in milliseconds.
+    If omitted a standard value of 10000 milliseconds is used.*/
+  auto& msg_params = (*message_)[strings::msg_params];
+  uint32_t duration_timeout = msg_params[strings::duration].asUInt();
+
+  default_timeout_ += duration_timeout;
+
+  // If soft buttons are present, SDL will not use initiate timeout tracking for
+  // response.
+  if (msg_params.keyExists(strings::soft_buttons)) {
+    LOG4CXX_INFO(logger_,
+                 "Request contains soft buttons - request timeout "
+                 "will be set to 0.");
+    default_timeout_ = 0;
+  }
+
+  return true;
+}
+
+void SubtleAlertRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  uint32_t app_id =
+      (*message_)[strings::params][strings::connection_key].asInt();
+
+  if (!Validate(app_id)) {
+    // Invalid command, abort execution
+    return;
+  }
+  bool tts_chunks_exists =
+      (*message_)[strings::msg_params].keyExists(strings::tts_chunks);
+  size_t length_tts_chunks = 0;
+
+  if (tts_chunks_exists) {
+    length_tts_chunks =
+        (*message_)[strings::msg_params][strings::tts_chunks].length();
+  }
+
+  awaiting_tts_speak_response_ = (tts_chunks_exists && length_tts_chunks);
+
+  SendSubtleAlertRequest(app_id);
+  if (awaiting_tts_speak_response_) {
+    SendSpeakRequest(app_id, tts_chunks_exists, length_tts_chunks);
+  }
+}
+
+void SubtleAlertRequest::on_event(const event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const smart_objects::SmartObject& message = event.smart_object();
+
+  switch (event.id()) {
+    case hmi_apis::FunctionID::TTS_OnResetTimeout:
+    case hmi_apis::FunctionID::UI_OnResetTimeout: {
+      LOG4CXX_INFO(logger_,
+                   "Received UI_OnResetTimeout event "
+                   " or TTS_OnResetTimeout event"
+                       << awaiting_tts_speak_response_ << " "
+                       << awaiting_tts_stop_speaking_response_ << " "
+                       << awaiting_ui_subtle_alert_response_);
+      application_manager_.updateRequestTimeout(
+          connection_key(), correlation_id(), default_timeout());
+      break;
+    }
+    case hmi_apis::FunctionID::UI_SubtleAlert: {
+      LOG4CXX_INFO(logger_, "Received UI_SubtleAlert event");
+      // Unsubscribe from event to avoid unwanted messages
+      EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_UI);
+      unsubscribe_from_event(hmi_apis::FunctionID::UI_SubtleAlert);
+      awaiting_ui_subtle_alert_response_ = false;
+      HmiInterfaces::InterfaceState ui_interface_state =
+          application_manager_.hmi_interfaces().GetInterfaceState(
+              HmiInterfaces::HMI_INTERFACE_UI);
+
+      if (awaiting_tts_speak_response_ &&
+          HmiInterfaces::STATE_NOT_AVAILABLE != ui_interface_state) {
+        awaiting_tts_stop_speaking_response_ = true;
+        StartAwaitForInterface(HmiInterfaces::HMI_INTERFACE_TTS);
+        SendHMIRequest(hmi_apis::FunctionID::TTS_StopSpeaking, NULL, true);
+        is_tts_stop_speaking_sent_ = true;
+      }
+      subtle_alert_result_ = static_cast<hmi_apis::Common_Result::eType>(
+          message[strings::params][hmi_response::code].asInt());
+
+      // Mobile Alert request is successful when UI_SubtleAlert is successful
+      subtle_alert_response_params_ = message[strings::msg_params];
+      GetInfo(message, ui_response_info_);
+      break;
+    }
+    case hmi_apis::FunctionID::TTS_Speak: {
+      LOG4CXX_INFO(logger_, "Received TTS_Speak event");
+      // Unsubscribe from event to avoid unwanted messages
+      EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_TTS);
+      unsubscribe_from_event(hmi_apis::FunctionID::TTS_Speak);
+      awaiting_tts_speak_response_ = false;
+      tts_speak_result_ = static_cast<hmi_apis::Common_Result::eType>(
+          message[strings::params][hmi_response::code].asInt());
+      GetInfo(message, tts_response_info_);
+      break;
+    }
+    case hmi_apis::FunctionID::TTS_StopSpeaking: {
+      LOG4CXX_INFO(logger_, "Received TTS_StopSpeaking event");
+      EndAwaitForInterface(HmiInterfaces::HMI_INTERFACE_TTS);
+      // Unsubscribe from event to avoid unwanted messages
+      unsubscribe_from_event(hmi_apis::FunctionID::TTS_StopSpeaking);
+      awaiting_tts_stop_speaking_response_ = false;
+      break;
+    }
+    default: {
+      LOG4CXX_ERROR(logger_, "Received unknown event" << event.id());
+      return;
+    }
+  }
+
+  if (HasHmiResponsesToWait()) {
+    return;
+  }
+  mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM;
+  std::string info;
+  const bool result = PrepareResponseParameters(result_code, info);
+  SendResponse(result,
+               result_code,
+               info.empty() ? NULL : info.c_str(),
+               &subtle_alert_response_params_);
+}
+
+bool SubtleAlertRequest::PrepareResponseParameters(
+    mobile_apis::Result::eType& result_code, std::string& info) {
+  app_mngr::commands::ResponseInfo ui_subtle_alert_info(
+      subtle_alert_result_,
+      HmiInterfaces::HMI_INTERFACE_UI,
+      application_manager_);
+  app_mngr::commands::ResponseInfo tts_alert_info(
+      tts_speak_result_,
+      HmiInterfaces::HMI_INTERFACE_TTS,
+      application_manager_);
+
+  bool result =
+      PrepareResultForMobileResponse(ui_subtle_alert_info, tts_alert_info);
+
+  /* result=false if UI interface is ok and TTS interface = UNSUPPORTED_RESOURCE
+   * and sdl receive TTS.IsReady=true or SDL doesn't receive response for
+   * TTS.IsReady.
+   */
+  if (result && ui_subtle_alert_info.is_ok &&
+      tts_alert_info.is_unsupported_resource &&
+      HmiInterfaces::STATE_NOT_AVAILABLE != tts_alert_info.interface_state) {
+    result = false;
+  }
+  result_code = mobile_apis::Result::WARNINGS;
+  if ((ui_subtle_alert_info.is_ok || ui_subtle_alert_info.is_not_used) &&
+      tts_alert_info.is_unsupported_resource &&
+      HmiInterfaces::STATE_AVAILABLE == tts_alert_info.interface_state) {
+    tts_response_info_ = "Unsupported phoneme type sent in a prompt";
+    info = app_mngr::commands::MergeInfos(ui_subtle_alert_info,
+                                          ui_response_info_,
+                                          tts_alert_info,
+                                          tts_response_info_);
+    return result;
+  }
+  // Ignore TTS.Speak result if ABORTED due to TTS.StopSpeaking request
+  if (is_tts_stop_speaking_sent_ &&
+      hmi_apis::Common_Result::ABORTED == tts_alert_info.result_code) {
+    result_code =
+        MessageHelper::HMIToMobileResult(ui_subtle_alert_info.result_code);
+    info = app_mngr::commands::MergeInfos(ui_subtle_alert_info,
+                                          ui_response_info_,
+                                          tts_alert_info,
+                                          tts_response_info_);
+    return ui_subtle_alert_info.is_ok;
+  }
+  result_code =
+      PrepareResultCodeForResponse(ui_subtle_alert_info, tts_alert_info);
+  info = app_mngr::commands::MergeInfos(ui_subtle_alert_info,
+                                        ui_response_info_,
+                                        tts_alert_info,
+                                        tts_response_info_);
+  // Mobile Alert request is successful when UI_SubtleAlert is successful
+  if (is_ui_subtle_alert_sent_ && !ui_subtle_alert_info.is_ok) {
+    return false;
+  }
+  return result;
+}
+
+bool SubtleAlertRequest::Validate(uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  ApplicationSharedPtr app = application_manager_.application(app_id);
+
+  if (!app) {
+    LOG4CXX_ERROR(logger_, "No application associated with session key");
+    SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED);
+    return false;
+  }
+
+  if (mobile_apis::HMILevel::HMI_BACKGROUND ==
+          app->hmi_level(mobile_apis::PredefinedWindows::DEFAULT_WINDOW) &&
+      app->AreCommandLimitsExceeded(
+          static_cast<mobile_apis::FunctionID::eType>(function_id()),
+          application_manager::TLimitSource::POLICY_TABLE)) {
+    LOG4CXX_ERROR(logger_, "SubtleAlert frequency is too high.");
+    SendResponse(false,
+                 mobile_apis::Result::REJECTED,
+                 "SubtleAlert frequency is too high.");
+    return false;
+  }
+
+  if (!CheckStrings()) {
+    SendResponse(false, mobile_apis::Result::INVALID_DATA);
+    return false;
+  }
+
+  // ProcessSoftButtons checks strings on the contents incorrect character
+
+  mobile_apis::Result::eType processing_result =
+      MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params],
+                                        app,
+                                        policy_handler_,
+                                        application_manager_);
+
+  if (mobile_apis::Result::SUCCESS != processing_result) {
+    LOG4CXX_ERROR(logger_, "INVALID_DATA!");
+    SendResponse(false, processing_result);
+    return false;
+  }
+
+  // check if mandatory params(alertText1 and TTSChunk) specified
+  if ((!(*message_)[strings::msg_params].keyExists(strings::alert_text1)) &&
+      (!(*message_)[strings::msg_params].keyExists(strings::alert_text2)) &&
+      (!(*message_)[strings::msg_params].keyExists(strings::tts_chunks))) {
+    LOG4CXX_ERROR(logger_, "Mandatory parameters are missing");
+    SendResponse(false,
+                 mobile_apis::Result::INVALID_DATA,
+                 "Mandatory parameters are missing");
+    return false;
+  }
+
+  if ((*message_)[strings::msg_params].keyExists(strings::tts_chunks)) {
+    smart_objects::SmartObject& tts_chunks =
+        (*message_)[strings::msg_params][strings::tts_chunks];
+    mobile_apis::Result::eType verification_result =
+        MessageHelper::VerifyTtsFiles(tts_chunks, app, application_manager_);
+
+    if (mobile_apis::Result::FILE_NOT_FOUND == verification_result) {
+      LOG4CXX_ERROR(
+          logger_,
+          "MessageHelper::VerifyTtsFiles return " << verification_result);
+      SendResponse(false,
+                   mobile_apis::Result::FILE_NOT_FOUND,
+                   "One or more files needed for tts_chunks are not present");
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void SubtleAlertRequest::SendSubtleAlertRequest(int32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  ApplicationSharedPtr app = application_manager_.application(app_id);
+
+  smart_objects::SmartObject msg_params =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
+
+  msg_params[hmi_request::alert_strings] =
+      smart_objects::SmartObject(smart_objects::SmartType_Array);
+
+  if ((*message_)[strings::msg_params].keyExists(strings::cancel_id)) {
+    msg_params[strings::cancel_id] =
+        (*message_)[strings::msg_params][strings::cancel_id].asInt();
+  }
+
+  int32_t index = 0;
+  if ((*message_)[strings::msg_params].keyExists(strings::alert_text1)) {
+    msg_params[hmi_request::alert_strings][index][hmi_request::field_name] =
+        hmi_apis::Common_TextFieldName::subtleAlertText1;
+    msg_params[hmi_request::alert_strings][index][hmi_request::field_text] =
+        (*message_)[strings::msg_params][strings::alert_text1];
+    index++;
+  }
+  if ((*message_)[strings::msg_params].keyExists(strings::alert_text2)) {
+    msg_params[hmi_request::alert_strings][index][hmi_request::field_name] =
+        hmi_apis::Common_TextFieldName::subtleAlertText2;
+    msg_params[hmi_request::alert_strings][index][hmi_request::field_text] =
+        (*message_)[strings::msg_params][strings::alert_text2];
+    index++;
+  }
+
+  // softButtons
+  if ((*message_)[strings::msg_params].keyExists(strings::soft_buttons)) {
+    msg_params[hmi_request::soft_buttons] =
+        (*message_)[strings::msg_params][strings::soft_buttons];
+    MessageHelper::SubscribeApplicationToSoftButton(
+        (*message_)[strings::msg_params], app, function_id());
+  } else {
+    msg_params[strings::duration] =
+        (*message_)[strings::msg_params][strings::duration].asUInt();
+  }
+
+  if ((*message_)[strings::msg_params].keyExists(strings::alert_icon)) {
+    auto verification_result = MessageHelper::VerifyImage(
+        (*message_)[strings::msg_params][strings::alert_icon],
+        app,
+        application_manager_);
+
+    if (mobile_apis::Result::INVALID_DATA == verification_result) {
+      LOG4CXX_ERROR(logger_, "Image verification failed.");
+      SendResponse(false, verification_result);
+      return;
+    }
+
+    msg_params[strings::alert_icon] =
+        (*message_)[strings::msg_params][strings::alert_icon];
+  }
+
+  // app_id
+  msg_params[strings::app_id] = app_id;
+
+  // PASA Alert type
+  msg_params[strings::alert_type] = hmi_apis::Common_AlertType::UI;
+  if (awaiting_tts_speak_response_) {
+    msg_params[strings::alert_type] = hmi_apis::Common_AlertType::BOTH;
+  }
+
+  // check out if there are alert strings or soft buttons
+  if (msg_params[hmi_request::alert_strings].length() > 0 ||
+      msg_params.keyExists(hmi_request::soft_buttons)) {
+    awaiting_ui_subtle_alert_response_ = true;
+    is_ui_subtle_alert_sent_ = true;
+    StartAwaitForInterface(HmiInterfaces::HMI_INTERFACE_UI);
+    SendHMIRequest(hmi_apis::FunctionID::UI_SubtleAlert, &msg_params, true);
+  }
+}
+
+void SubtleAlertRequest::SendSpeakRequest(int32_t app_id,
+                                          bool tts_chunks_exists,
+                                          size_t length_tts_chunks) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  using namespace hmi_apis;
+  using namespace smart_objects;
+  // crate HMI speak request
+  SmartObject msg_params = smart_objects::SmartObject(SmartType_Map);
+  if (tts_chunks_exists && length_tts_chunks) {
+    msg_params[hmi_request::tts_chunks] =
+        smart_objects::SmartObject(SmartType_Array);
+    msg_params[hmi_request::tts_chunks] =
+        (*message_)[strings::msg_params][strings::tts_chunks];
+  }
+  msg_params[strings::app_id] = app_id;
+  msg_params[hmi_request::speak_type] = Common_MethodName::SUBTLE_ALERT;
+  StartAwaitForInterface(HmiInterfaces::HMI_INTERFACE_TTS);
+  SendHMIRequest(FunctionID::TTS_Speak, &msg_params, true);
+}
+
+bool SubtleAlertRequest::CheckStrings() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const char* str = NULL;
+
+  if ((*message_)[strings::msg_params].keyExists(strings::alert_text1)) {
+    str = (*message_)[strings::msg_params][strings::alert_text1].asCharArray();
+    if (!CheckSyntax(str)) {
+      LOG4CXX_ERROR(logger_, "Invalid alert_text_1 syntax check failed");
+      return false;
+    }
+  }
+
+  if ((*message_)[strings::msg_params].keyExists(strings::alert_text2)) {
+    str = (*message_)[strings::msg_params][strings::alert_text2].asCharArray();
+    if (!CheckSyntax(str)) {
+      LOG4CXX_ERROR(logger_, "Invalid alert_text_2 syntax check failed");
+      return false;
+    }
+  }
+
+  if ((*message_)[strings::msg_params].keyExists(strings::tts_chunks)) {
+    smart_objects::SmartObject& tts_chunks_array =
+        (*message_)[strings::msg_params][strings::tts_chunks];
+    for (size_t i = 0; i < tts_chunks_array.length(); ++i) {
+      str = tts_chunks_array[i][strings::text].asCharArray();
+      if (strlen(str) && !CheckSyntax(str)) {
+        LOG4CXX_ERROR(logger_, "Invalid tts_chunks text syntax check failed");
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool SubtleAlertRequest::HasHmiResponsesToWait() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return awaiting_ui_subtle_alert_response_ || awaiting_tts_speak_response_ ||
+         awaiting_tts_stop_speaking_response_;
+}
+
+}  // namespace commands
+}  // namespace sdl_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/subtle_alert_response.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/subtle_alert_response.cc
new file mode 100644
index 0000000000..ad9252997b
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/subtle_alert_response.cc
@@ -0,0 +1,64 @@
+/*
+ Copyright (c) 2020, Ford Motor Company, Livio
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided with the
+ distribution.
+
+ Neither the name of the the copyright holders nor the names of their
+ contributors may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sdl_rpc_plugin/commands/mobile/subtle_alert_response.h"
+
+#include "application_manager/application_impl.h"
+#include "interfaces/MOBILE_API.h"
+
+namespace sdl_rpc_plugin {
+using namespace application_manager;
+
+namespace commands {
+
+SubtleAlertResponse::SubtleAlertResponse(
+    const application_manager::commands::MessageSharedPtr& message,
+    ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler)
+    : CommandResponseImpl(message,
+                          application_manager,
+                          rpc_service,
+                          hmi_capabilities,
+                          policy_handler) {}
+
+SubtleAlertResponse::~SubtleAlertResponse() {}
+
+void SubtleAlertResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  rpc_service_.SendMessageToMobile(message_);
+}
+
+}  // namespace commands
+}  // namespace sdl_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc
index b89a8dbd68..0289a92290 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/hmi_command_factory.cc
@@ -135,6 +135,8 @@
 #include "sdl_rpc_plugin/commands/hmi/ui_show_response.h"
 #include "sdl_rpc_plugin/commands/hmi/ui_slider_request.h"
 #include "sdl_rpc_plugin/commands/hmi/ui_slider_response.h"
+#include "sdl_rpc_plugin/commands/hmi/ui_subtle_alert_request.h"
+#include "sdl_rpc_plugin/commands/hmi/ui_subtle_alert_response.h"
 #include "sdl_rpc_plugin/commands/hmi/update_app_list_request.h"
 #include "sdl_rpc_plugin/commands/hmi/update_app_list_response.h"
 #include "sdl_rpc_plugin/commands/hmi/update_device_list_request.h"
@@ -229,6 +231,7 @@
 #include "sdl_rpc_plugin/commands/hmi/on_ui_keyboard_input_notification.h"
 #include "sdl_rpc_plugin/commands/hmi/on_ui_language_change_notification.h"
 #include "sdl_rpc_plugin/commands/hmi/on_ui_reset_timeout_notification.h"
+#include "sdl_rpc_plugin/commands/hmi/on_ui_subtle_alert_pressed_notification.h"
 #include "sdl_rpc_plugin/commands/hmi/on_ui_touch_event_notification.h"
 #include "sdl_rpc_plugin/commands/hmi/on_vr_command_notification.h"
 #include "sdl_rpc_plugin/commands/hmi/on_vr_language_change_notification.h"
@@ -511,6 +514,11 @@ CommandCreator& HMICommandFactory::get_creator_factory(
                  ? factory.GetCreator<commands::UIAlertRequest>()
                  : factory.GetCreator<commands::UIAlertResponse>();
     }
+    case hmi_apis::FunctionID::UI_SubtleAlert: {
+      return hmi_apis::messageType::request == message_type
+                 ? factory.GetCreator<commands::UISubtleAlertRequest>()
+                 : factory.GetCreator<commands::UISubtleAlertResponse>();
+    }
     case hmi_apis::FunctionID::VR_IsReady: {
       return hmi_apis::messageType::request == message_type
                  ? factory.GetCreator<commands::VRIsReadyRequest>()
@@ -923,6 +931,9 @@ CommandCreator& HMICommandFactory::get_creator_factory(
     case hmi_apis::FunctionID::BasicCommunication_OnAppPropertiesChange: {
       return factory.GetCreator<commands::OnAppPropertiesChangeNotification>();
     }
+    case hmi_apis::FunctionID::UI_OnSubtleAlertPressed: {
+      return factory.GetCreator<commands::OnUISubtleAlertPressedNotification>();
+    }
     default: { return factory.GetCreator<InvalidCommand>(); }
   }
 }
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/mobile_command_factory.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/mobile_command_factory.cc
index c6f4b64636..5855309f80 100644
--- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/mobile_command_factory.cc
+++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/mobile_command_factory.cc
@@ -31,6 +31,7 @@
  */
 
 #include "sdl_rpc_plugin/mobile_command_factory.h"
+
 #include "interfaces/MOBILE_API.h"
 #include "sdl_rpc_plugin/commands/mobile/add_command_request.h"
 #include "sdl_rpc_plugin/commands/mobile/add_command_response.h"
@@ -87,6 +88,7 @@
 #include "sdl_rpc_plugin/commands/mobile/on_keyboard_input_notification.h"
 #include "sdl_rpc_plugin/commands/mobile/on_language_change_notification.h"
 #include "sdl_rpc_plugin/commands/mobile/on_permissions_change_notification.h"
+#include "sdl_rpc_plugin/commands/mobile/on_subtle_alert_pressed_notification.h"
 #include "sdl_rpc_plugin/commands/mobile/on_system_capability_updated_notification.h"
 #include "sdl_rpc_plugin/commands/mobile/on_system_request_notification.h"
 #include "sdl_rpc_plugin/commands/mobile/on_tbt_client_state_notification.h"
@@ -132,6 +134,8 @@
 #include "sdl_rpc_plugin/commands/mobile/subscribe_button_response.h"
 #include "sdl_rpc_plugin/commands/mobile/subscribe_way_points_request.h"
 #include "sdl_rpc_plugin/commands/mobile/subscribe_way_points_response.h"
+#include "sdl_rpc_plugin/commands/mobile/subtle_alert_request.h"
+#include "sdl_rpc_plugin/commands/mobile/subtle_alert_response.h"
 #include "sdl_rpc_plugin/commands/mobile/system_request.h"
 #include "sdl_rpc_plugin/commands/mobile/system_response.h"
 #include "sdl_rpc_plugin/commands/mobile/unregister_app_interface_request.h"
@@ -222,6 +226,11 @@ CommandCreator& MobileCommandFactory::get_command_creator(
                  ? factory.GetCreator<commands::AlertRequest>()
                  : factory.GetCreator<commands::AlertResponse>();
     }
+    case mobile_apis::FunctionID::SubtleAlertID: {
+      return mobile_api::messageType::request == message_type
+                 ? factory.GetCreator<commands::SubtleAlertRequest>()
+                 : factory.GetCreator<commands::SubtleAlertResponse>();
+    }
     case mobile_apis::FunctionID::SpeakID: {
       return mobile_api::messageType::request == message_type
                  ? factory.GetCreator<commands::SpeakRequest>()
@@ -458,6 +467,9 @@ CommandCreator& MobileCommandFactory::get_notification_creator(
     case mobile_apis::FunctionID::OnWayPointChangeID: {
       return factory.GetCreator<commands::OnWayPointChangeNotification>();
     }
+    case mobile_apis::FunctionID::OnSubtleAlertPressedID: {
+      return factory.GetCreator<commands::OnSubtleAlertPressedNotification>();
+    }
     default: {}
   }
   return factory.GetCreator<InvalidCommand>();