Fix SDL does not set the app to NONE HMI level after a rejecting of StartService (#3082)

* Fix HMI level on StartServiceNAck

* fixup! Fix HMI level on StartServiceNAck

4 files changed, 138 insertions, 12 deletions

diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index 4b1f8a4601..e88c954c18 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -1138,6 +1138,14 @@ class ApplicationManagerImpl
 
  private:
   /**
+   * @brief Removes service status record for service that failed to start
+   * @param app Application whose service status record should be removed
+   * @param Service type which status record should be removed
+   */
+  bool HandleRejectedServiceStatus(
+      ApplicationSharedPtr app,
+      const hmi_apis::Common_ServiceType::eType service_type);
+  /**
    * @brief PullLanguagesInfo allows to pull information about languages.
    *
    * @param app_data entry to parse
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 4cd1a7764f..8044e8b6cd 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -2068,6 +2068,51 @@ void ApplicationManagerImpl::ProcessServiceStatusUpdate(
       service_type, service_event, reason, app_id);
 
   rpc_service_->ManageHMICommand(notification);
+
+  if (hmi_apis::Common_ServiceEvent::REQUEST_REJECTED == service_event &&
+      HandleRejectedServiceStatus(app, service_type)) {
+    state_ctrl_.SetRegularState(app,
+                                mobile_apis::PredefinedWindows::DEFAULT_WINDOW,
+                                mobile_apis::HMILevel::HMI_NONE,
+                                true);
+  }
+}
+
+bool ApplicationManagerImpl::HandleRejectedServiceStatus(
+    ApplicationSharedPtr app,
+    const hmi_apis::Common_ServiceType::eType service_type) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (!app) {
+    LOG4CXX_WARN(logger_, "Received invalid app");
+    return false;
+  }
+
+  switch (service_type) {
+    case hmi_apis::Common_ServiceType::VIDEO:
+    case hmi_apis::Common_ServiceType::AUDIO: {
+      {
+        sync_primitives::AutoLock lock(navi_service_status_lock_);
+        auto app_services = navi_service_status_.find(app->app_id());
+        if (navi_service_status_.end() != app_services) {
+          navi_service_status_.erase(app_services);
+        }
+      }
+      LOG4CXX_DEBUG(logger_,
+                    "The start of service"
+                        << service_type << " for appID: " << app
+                        << " is failed. Service info has been removed");
+      return true;
+    }
+    case hmi_apis::Common_ServiceType::RPC: {
+      connection_handler().SendEndService(app->app_id(),
+                                          protocol_handler::ServiceType::kRpc);
+      LOG4CXX_DEBUG(logger_, "RPC service for appID: " << app << " is stopped");
+      return true;
+    }
+    default:
+      LOG4CXX_DEBUG(logger_, "Unknown service type: " << service_type);
+      return false;
+  }
 }
 
 void ApplicationManagerImpl::OnSecondaryTransportStartedCallback(
@@ -3365,6 +3410,7 @@ void ApplicationManagerImpl::EndNaviServices(uint32_t app_id) {
       connection_handler().SendEndService(app_id, ServiceType::kAudio);
       app->StopStreamingForce(ServiceType::kAudio);
     }
+
     DisallowStreaming(app_id);
 
     navi_app_to_stop_.push_back(app_id);
diff --git a/src/components/application_manager/test/application_manager_impl_test.cc b/src/components/application_manager/test/application_manager_impl_test.cc
index ff1a9b047d..152d577cda 100644
--- a/src/components/application_manager/test/application_manager_impl_test.cc
+++ b/src/components/application_manager/test/application_manager_impl_test.cc
@@ -39,12 +39,14 @@
 #include "application_manager/application.h"
 #include "application_manager/application_impl.h"
 #include "application_manager/application_manager_impl.h"
+#include "application_manager/hmi_state.h"
 #include "application_manager/mock_app_service_manager.h"
 #include "application_manager/mock_application.h"
 #include "application_manager/mock_application_manager_settings.h"
 #include "application_manager/mock_resumption_data.h"
 #include "application_manager/mock_rpc_plugin_manager.h"
 #include "application_manager/mock_rpc_service.h"
+#include "application_manager/mock_state_controller.h"
 #include "application_manager/policies/mock_policy_handler_interface.h"
 #include "application_manager/resumption/resume_ctrl_impl.h"
 #include "application_manager/test/include/application_manager/mock_message_helper.h"
@@ -88,6 +90,7 @@ using ::testing::SaveArg;
 using ::testing::SetArgPointee;
 using ::testing::SetArgReferee;
 
+using test::components::application_manager_test::MockStateController;
 using test::components::policy_test::MockPolicyHandlerInterface;
 
 using namespace application_manager;
@@ -98,6 +101,7 @@ ACTION_P6(InvokeMemberFuncWithArg4, ptr, memberFunc, a, b, c, d) {
 }
 
 namespace {
+const uint32_t kCorrelationID = 54321u;
 const std::string kDirectoryName = "./test_storage";
 const uint32_t kTimeout = 10000u;
 connection_handler::DeviceHandle kDeviceId = 12345u;
@@ -170,8 +174,21 @@ class ApplicationManagerImplTest
  protected:
   void SetUp() OVERRIDE {
     CreateAppManager();
+    ON_CALL(mock_state_ctrl_,
+            SetRegularState(_,
+                            mobile_apis::PredefinedWindows::DEFAULT_WINDOW,
+                            mobile_apis::HMILevel::HMI_NONE,
+                            true));
     ON_CALL(*mock_app_ptr_, app_id()).WillByDefault(Return(kConnectionKey));
     ON_CALL(*mock_app_ptr_, device()).WillByDefault(Return(kDeviceId));
+
+    HmiStatePtr hmi_state(std::make_shared<HmiState>(
+        mock_app_ptr_, mock_app_mngr_, HmiState::STATE_ID_REGULAR));
+
+    ON_CALL(*mock_app_ptr_,
+            RegularHmiState(mobile_apis::PredefinedWindows::DEFAULT_WINDOW))
+        .WillByDefault(Return(hmi_state));
+
     ON_CALL(mock_session_observer_, GetDataOnSessionKey(_, _, _, _))
         .WillByDefault(DoAll(SetArgPointee<3u>(kDeviceId), Return(0)));
     ON_CALL(mock_connection_handler_, GetDataOnSessionKey(_, _, _, &kDeviceId))
@@ -195,6 +212,9 @@ class ApplicationManagerImplTest
         smart_objects::SmartType_Map);
     ON_CALL(*mock_message_helper_, CreateModuleInfoSO(_, _))
         .WillByDefault(Return(request));
+    ON_CALL(*mock_message_helper_, GetBCCloseApplicationRequestToHMI(_, _))
+        .WillByDefault(Return(std::make_shared<smart_objects::SmartObject>(
+            smart_objects::SmartType_Map)));
     ON_CALL(*mock_policy_handler_, GetStatisticManager())
         .WillByDefault(Return(mock_statistics_manager_));
   }
@@ -221,13 +241,30 @@ class ApplicationManagerImplTest
 
     app_manager_impl_.reset(new am::ApplicationManagerImpl(
         mock_application_manager_settings_, mock_policy_settings_));
-    mock_app_ptr_ = std::shared_ptr<MockApplication>(new MockApplication());
+    mock_app_ptr_ = std::shared_ptr<NiceMock<MockApplication> >(
+        new NiceMock<MockApplication>());
     app_manager_impl_->set_protocol_handler(&mock_protocol_handler_);
     app_manager_impl_->SetMockPolicyHandler(mock_policy_handler_);
     ASSERT_TRUE(app_manager_impl_.get());
     ASSERT_TRUE(mock_app_ptr_.get());
   }
 
+  application_manager::commands::MessageSharedPtr CreateCloseAppMessage() {
+    using namespace application_manager;
+
+    smart_objects::SmartObjectSPtr message =
+        std::make_shared<smart_objects::SmartObject>(
+            smart_objects::SmartType_Map);
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  hmi_apis::FunctionID::BasicCommunication_CloseApplication;
+    (*message)[strings::params][strings::message_type] = MessageType::kRequest;
+    (*message)[strings::params][strings::correlation_id] = kCorrelationID;
+    (*message)[strings::msg_params][strings::app_id] = kAppId;
+
+    return message;
+  }
+
   void AddMockApplication() {
     app_manager_impl_->AddMockApplication(mock_app_ptr_);
   }
@@ -273,6 +310,7 @@ class ApplicationManagerImplTest
   NiceMock<policy_test::MockPolicySettings> mock_policy_settings_;
   std::shared_ptr<NiceMock<resumption_test::MockResumptionData> > mock_storage_;
 
+  MockStateController mock_state_ctrl_;
   MockRPCService* mock_rpc_service_;
   resumption_test::MockLastState mock_last_state_;
   NiceMock<con_test::MockConnectionHandler> mock_connection_handler_;
@@ -284,7 +322,7 @@ class ApplicationManagerImplTest
   MockAppServiceManager* mock_app_service_manager_;
   application_manager::MockMessageHelper* mock_message_helper_;
 
-  std::shared_ptr<MockApplication> mock_app_ptr_;
+  std::shared_ptr<NiceMock<MockApplication> > mock_app_ptr_;
   NiceMock<protocol_handler_test::MockProtocolHandler> mock_protocol_handler_;
   std::shared_ptr<NiceMock<usage_statistics_test::MockStatisticsManager> >
       mock_statistics_manager_;
@@ -344,11 +382,16 @@ TEST_P(ApplicationManagerImplTest,
 
   ON_CALL(*mock_app_ptr_, app_id()).WillByDefault(Return(kConnectionKey));
 
+  auto close_message = CreateCloseAppMessage();
+  ON_CALL(*mock_message_helper_, GetBCCloseApplicationRequestToHMI(_, _))
+      .WillByDefault(Return(close_message));
   ON_CALL(*mock_message_helper_, CreateOnServiceUpdateNotification(_, _, _, _))
       .WillByDefault(Return(notification_));
 
-  EXPECT_CALL(*mock_rpc_service_, ManageHMICommand(notification_, _))
-      .WillOnce(Return(true));
+  ON_CALL(*mock_rpc_service_, ManageHMICommand(notification_, _))
+      .WillByDefault(Return(true));
+  ON_CALL(*mock_rpc_service_, ManageHMICommand(close_message, _))
+      .WillByDefault(Return(true));
 
   app_manager_impl_->ProcessServiceStatusUpdate(kConnectionKey,
                                                 GetParam().service_type_,
diff --git a/src/components/application_manager/test/state_controller/state_controller_test.cc b/src/components/application_manager/test/state_controller/state_controller_test.cc
index 0fe40366d6..9799dbcac2 100644
--- a/src/components/application_manager/test/state_controller/state_controller_test.cc
+++ b/src/components/application_manager/test/state_controller/state_controller_test.cc
@@ -71,6 +71,8 @@ using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::Truly;
 
+using application_manager::MockMessageHelper;
+
 namespace test {
 namespace components {
 namespace state_controller_test {
@@ -154,7 +156,6 @@ class StateControllerImplTest : public ::testing::Test {
   ~StateControllerImplTest() {
     Mock::VerifyAndClearExpectations(&message_helper_mock_);
   }
-
   NiceMock<application_manager_test::MockApplicationManager> app_manager_mock_;
   NiceMock<application_manager_test::MockRPCService> mock_rpc_service_;
   NiceMock<policy_test::MockPolicyHandlerInterface> policy_interface_;
@@ -1014,7 +1015,6 @@ class StateControllerImplTest : public ::testing::Test {
     ON_CALL(app_manager_mock_, event_dispatcher())
         .WillByDefault(ReturnRef(mock_event_dispatcher_));
     state_ctrl_ = std::make_shared<am::StateControllerImpl>(app_manager_mock_);
-
     ON_CALL(app_manager_mock_, applications())
         .WillByDefault(Return(applications_));
     ConfigureApps();
@@ -1027,6 +1027,22 @@ class StateControllerImplTest : public ::testing::Test {
     delete conn_handler;
   }
 
+  application_manager::commands::MessageSharedPtr CreateCloseAppMessage() {
+    using namespace application_manager;
+
+    smart_objects::SmartObjectSPtr message =
+        std::make_shared<smart_objects::SmartObject>(
+            smart_objects::SmartType_Map);
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  hmi_apis::FunctionID::BasicCommunication_CloseApplication;
+    (*message)[strings::params][strings::message_type] = MessageType::kRequest;
+    (*message)[strings::params][strings::correlation_id] = kCorrID;
+    (*message)[strings::msg_params][strings::app_id] = kHMIAppID;
+
+    return message;
+  }
+
   void SetConnection() {
     conn_handler = new connection_handler::ConnectionHandlerImpl(
         mock_connection_handler__settings, mock_transport_manager);
@@ -1231,6 +1247,12 @@ class StateControllerImplTest : public ::testing::Test {
     using smart_objects::SmartObject;
     namespace FunctionID = hmi_apis::FunctionID;
 
+    ON_CALL(message_helper_mock_, GetBCCloseApplicationRequestToHMI(_, _))
+        .WillByDefault(Return(CreateCloseAppMessage()));
+    ON_CALL(app_manager_mock_, GetRPCService())
+        .WillByDefault(ReturnRef(mock_rpc_service_));
+    ON_CALL(mock_rpc_service_, ManageHMICommand(_, _))
+        .WillByDefault(Return(true));
     EXPECT_CALL(app_mock, CurrentHmiState(kDefaultWindowId))
         .WillRepeatedly(Return(NoneNotAudibleState()));
 
@@ -2587,14 +2609,20 @@ TEST_F(StateControllerImplTest,
 
 TEST_F(StateControllerImplTest, SetRegularStateWithNewHmiLvl) {
   using namespace mobile_apis;
+  auto message = CreateCloseAppMessage();
+  ON_CALL(message_helper_mock_, GetBCCloseApplicationRequestToHMI(_, _))
+      .WillByDefault(Return(message));
+  ON_CALL(app_manager_mock_, GetRPCService())
+      .WillByDefault(ReturnRef(mock_rpc_service_));
+  ON_CALL(mock_rpc_service_, ManageHMICommand(_, _))
+      .WillByDefault(Return(true));
+
+  ON_CALL(*simple_app_ptr_, RegularHmiState(kDefaultWindowId))
+      .WillByDefault(Return(NoneNotAudibleState()));
+  ON_CALL(*simple_app_ptr_, CurrentHmiState(kDefaultWindowId))
+      .WillByDefault(Return(NoneNotAudibleState()));
 
   HMILevel::eType set_lvl = HMILevel::HMI_NONE;
-  EXPECT_CALL(*simple_app_ptr_, RegularHmiState(kDefaultWindowId))
-      .WillOnce(Return(BackgroundState()));
-
-  EXPECT_CALL(*simple_app_ptr_, CurrentHmiState(kDefaultWindowId))
-      .WillOnce(Return(BackgroundState()))
-      .WillOnce(Return(BackgroundState()));
 
   state_ctrl_->SetRegularState(simple_app_, kDefaultWindowId, set_lvl);
 
@@ -2605,6 +2633,7 @@ TEST_F(StateControllerImplTest, SetRegularStateWithNewHmiLvl) {
   EXPECT_CALL(*simple_app_ptr_, CurrentHmiState(kDefaultWindowId))
       .WillOnce(Return(BackgroundState()))
       .WillOnce(Return(BackgroundState()));
+
   state_ctrl_->SetRegularState(simple_app_, kDefaultWindowId, set_lvl);
 
   set_lvl = HMILevel::HMI_FULL;