Provide specific behavior for navigation streaming HMI state

8 files changed, 113 insertions, 61 deletions

diff --git a/src/components/application_manager/include/application_manager/hmi_state.h b/src/components/application_manager/include/application_manager/hmi_state.h
index 22af0bdf5e..a22d32920a 100644
--- a/src/components/application_manager/include/application_manager/hmi_state.h
+++ b/src/components/application_manager/include/application_manager/hmi_state.h
@@ -70,6 +70,7 @@ class HmiState {
     STATE_ID_VR_SESSION,
     STATE_ID_TTS_SESSION,
     STATE_ID_VIDEO_STREAMING,
+    STATE_ID_NAVI_STREAMING,
     STATE_ID_DEACTIVATE_HMI,
     STATE_ID_AUDIO_SOURCE,
     STATE_ID_EMBEDDED_NAVI
@@ -300,13 +301,24 @@ class VideoStreamingHmiState : public HmiState {
   VideoStreamingHmiState(utils::SharedPtr<Application> app,
                          const ApplicationManager& app_mngr);
 
-  mobile_apis::AudioStreamingState::eType audio_streaming_state()
-      const OVERRIDE;
   mobile_apis::VideoStreamingState::eType video_streaming_state()
       const OVERRIDE;
 };
 
 /**
+ * @brief The NaviStreamingHmiState class implements logic of navigation
+ * streaming temporary state that is more specific than VideoStreamingHmiState
+ */
+class NaviStreamingHmiState : public VideoStreamingHmiState {
+ public:
+  NaviStreamingHmiState(utils::SharedPtr<Application> app,
+                        const ApplicationManager& app_mngr);
+
+  mobile_apis::AudioStreamingState::eType audio_streaming_state()
+      const OVERRIDE;
+};
+
+/**
  * @brief The PhoneCallHmiState class implements logic of PhoneCall temporary
  * state
  */
diff --git a/src/components/application_manager/include/application_manager/state_controller_impl.h b/src/components/application_manager/include/application_manager/state_controller_impl.h
index 61232c842c..58747fdd6e 100644
--- a/src/components/application_manager/include/application_manager/state_controller_impl.h
+++ b/src/components/application_manager/include/application_manager/state_controller_impl.h
@@ -156,14 +156,16 @@ class StateControllerImpl : public event_engine::EventObserver,
       const mobile_apis::HMILevel::eType default_level);
 
   /**
-   * @brief OnNaviStreamingStarted process Navi streaming started
+   * @brief OnVideoStreamingStarted process video streaming started
+   * @param app projection or navigation application starting streaming
    */
-  virtual void OnNaviStreamingStarted();
+  virtual void OnVideoStreamingStarted(ApplicationConstSharedPtr app);
 
   /**
-   * @brief OnNaviStreamingStopped process Navi streaming stopped
+   * @brief OnVideoStreamingStopped process video streaming stopped
+   * @param app projection or navigation application stopping streaming
    */
-  virtual void OnNaviStreamingStopped();
+  virtual void OnVideoStreamingStopped(ApplicationConstSharedPtr app);
 
   /**
    * @brief OnStateChanged send HMIStatusNotification if needed
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 3dc529a26e..408dcbf1da 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -3562,7 +3562,6 @@ void ApplicationManagerImpl::ForbidStreaming(uint32_t app_id) {
 
 void ApplicationManagerImpl::OnAppStreaming(
     uint32_t app_id, protocol_handler::ServiceType service_type, bool state) {
-  using namespace protocol_handler;
   LOG4CXX_AUTO_TRACE(logger_);
 
   ApplicationSharedPtr app = application(app_id);
@@ -3575,11 +3574,11 @@ void ApplicationManagerImpl::OnAppStreaming(
   DCHECK_OR_RETURN_VOID(media_manager_);
 
   if (state) {
-    state_ctrl_.OnNaviStreamingStarted();
+    state_ctrl_.OnVideoStreamingStarted(app);
     media_manager_->StartStreaming(app_id, service_type);
   } else {
     media_manager_->StopStreaming(app_id, service_type);
-    state_ctrl_.OnNaviStreamingStopped();
+    state_ctrl_.OnVideoStreamingStarted(app);
   }
 }
 
diff --git a/src/components/application_manager/src/hmi_state.cc b/src/components/application_manager/src/hmi_state.cc
index ebc5a67143..73d4b80a55 100644
--- a/src/components/application_manager/src/hmi_state.cc
+++ b/src/components/application_manager/src/hmi_state.cc
@@ -155,17 +155,31 @@ VideoStreamingHmiState::VideoStreamingHmiState(
     utils::SharedPtr<Application> app, const ApplicationManager& app_mngr)
     : HmiState(app, app_mngr, STATE_ID_VIDEO_STREAMING) {}
 
+mobile_apis::VideoStreamingState::eType
+VideoStreamingHmiState::video_streaming_state() const {
+  if (app_->IsVideoApplication()) {
+    return parent()->video_streaming_state();
+  }
+
+  return mobile_apis::VideoStreamingState::NOT_STREAMABLE;
+}
+
+NaviStreamingHmiState::NaviStreamingHmiState(utils::SharedPtr<Application> app,
+                                             const ApplicationManager& app_mngr)
+    : VideoStreamingHmiState(app, app_mngr) {
+  set_state_id(STATE_ID_NAVI_STREAMING);
+}
+
 mobile_apis::AudioStreamingState::eType
-VideoStreamingHmiState::audio_streaming_state() const {
+NaviStreamingHmiState::audio_streaming_state() const {
   using namespace helpers;
   using namespace mobile_apis;
 
   AudioStreamingState::eType expected_state = parent()->audio_streaming_state();
-  if (!app_->IsVideoApplication() &&
-      Compare<AudioStreamingState::eType, EQ, ONE>(
-          expected_state,
-          AudioStreamingState::AUDIBLE,
-          AudioStreamingState::ATTENUATED)) {
+  if (!is_navi_app() && Compare<AudioStreamingState::eType, EQ, ONE>(
+                            expected_state,
+                            AudioStreamingState::AUDIBLE,
+                            AudioStreamingState::ATTENUATED)) {
     if (app_mngr_.is_attenuated_supported()) {
       expected_state = AudioStreamingState::ATTENUATED;
     } else {
@@ -176,15 +190,6 @@ VideoStreamingHmiState::audio_streaming_state() const {
   return expected_state;
 }
 
-mobile_apis::VideoStreamingState::eType
-VideoStreamingHmiState::video_streaming_state() const {
-  if (app_->IsVideoApplication()) {
-    return parent()->video_streaming_state();
-  }
-
-  return mobile_apis::VideoStreamingState::NOT_STREAMABLE;
-}
-
 PhoneCallHmiState::PhoneCallHmiState(utils::SharedPtr<Application> app,
                                      const ApplicationManager& app_mngr)
     : HmiState(app, app_mngr, STATE_ID_PHONE_CALL) {}
@@ -287,6 +292,7 @@ const StateID2StrMap kStateID2StrMap =
         HmiState::StateID::STATE_ID_VR_SESSION, "VR_SESSION")(
         HmiState::StateID::STATE_ID_TTS_SESSION, "TTS_SESSION")(
         HmiState::StateID::STATE_ID_VIDEO_STREAMING, "VIDEO_STREAMING")(
+        HmiState::StateID::STATE_ID_NAVI_STREAMING, "NAVI_STREAMING")(
         HmiState::StateID::STATE_ID_DEACTIVATE_HMI, "DEACTIVATE_HMI")(
         HmiState::StateID::STATE_ID_AUDIO_SOURCE, "AUDIO_SOURCE")(
         HmiState::StateID::STATE_ID_EMBEDDED_NAVI, "EMBEDDED_NAVI");
diff --git a/src/components/application_manager/src/state_controller_impl.cc b/src/components/application_manager/src/state_controller_impl.cc
index 1eb75c4451..9615656675 100644
--- a/src/components/application_manager/src/state_controller_impl.cc
+++ b/src/components/application_manager/src/state_controller_impl.cc
@@ -936,12 +936,22 @@ void StateControllerImpl::OnAppDeactivated(
   DeactivateApp(app);
 }
 
-void StateControllerImpl::OnNaviStreamingStarted() {
-  ApplyTempState<HmiState::STATE_ID_VIDEO_STREAMING>();
+void StateControllerImpl::OnVideoStreamingStarted(
+    ApplicationConstSharedPtr app) {
+  if (app->is_navi()) {
+    ApplyTempState<HmiState::STATE_ID_NAVI_STREAMING>();
+  } else {
+    ApplyTempState<HmiState::STATE_ID_VIDEO_STREAMING>();
+  }
 }
 
-void StateControllerImpl::OnNaviStreamingStopped() {
-  CancelTempState<HmiState::STATE_ID_VIDEO_STREAMING>();
+void StateControllerImpl::OnVideoStreamingStopped(
+    ApplicationConstSharedPtr app) {
+  if (app->is_navi()) {
+    CancelTempState<HmiState::STATE_ID_NAVI_STREAMING>();
+  } else {
+    CancelTempState<HmiState::STATE_ID_VIDEO_STREAMING>();
+  }
 }
 
 bool StateControllerImpl::IsStateActive(HmiState::StateID state_id) const {
@@ -982,6 +992,10 @@ HmiStatePtr StateControllerImpl::CreateHmiState(
       new_state = MakeShared<VideoStreamingHmiState>(app, app_mngr_);
       break;
     }
+    case HmiState::STATE_ID_NAVI_STREAMING: {
+      new_state = MakeShared<NaviStreamingHmiState>(app, app_mngr_);
+      break;
+    }
     case HmiState::STATE_ID_REGULAR: {
       new_state = MakeShared<HmiState>(app, app_mngr_);
       break;
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 da8c156e9f..75aad1e225 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
@@ -864,7 +864,7 @@ class StateControllerImplTest : public ::testing::Test {
     valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_TTS_SESSION);
     valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_PHONE_CALL);
     valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_SAFETY_MODE);
-    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_VIDEO_STREAMING);
+    valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_NAVI_STREAMING);
   }
 
   void ConfigureApps() {
@@ -1074,18 +1074,19 @@ class StateControllerImplTest : public ::testing::Test {
   }
 
   void ApplyTempStatesForApplication(
-      NiceMock<application_manager_test::MockApplication>& application,
+      am::ApplicationSharedPtr app,
+      NiceMock<application_manager_test::MockApplication>& app_mock,
       std::vector<am::HmiState::StateID>& state_ids) {
     using smart_objects::SmartObject;
     using am::event_engine::Event;
     namespace FunctionID = hmi_apis::FunctionID;
 
-    EXPECT_CALL(application, CurrentHmiState())
+    EXPECT_CALL(app_mock, CurrentHmiState())
         .WillRepeatedly(Return(NoneNotAudibleState()));
 
     for (size_t i = 0; i < state_ids.size(); ++i) {
       am::HmiState::StateID state_id = state_ids[i];
-      EXPECT_CALL(application,
+      EXPECT_CALL(app_mock,
                   AddHMIState(Truly(HmiStatesIDComparator(state_id))));
       switch (state_id) {
         case am::HmiState::StateID::STATE_ID_VR_SESSION: {
@@ -1120,31 +1121,32 @@ class StateControllerImplTest : public ::testing::Test {
           state_ctrl_->on_event(emergency_event);
           break;
         }
-        case am::HmiState::StateID::STATE_ID_VIDEO_STREAMING: {
-          state_ctrl_->OnNaviStreamingStarted();
+        case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
+          state_ctrl_->OnVideoStreamingStarted(app);
           break;
         }
         default:
           break;
       }
-      EXPECT_CALL(application, AddHMIState(_)).Times(0);
+      EXPECT_CALL(app_mock, AddHMIState(_)).Times(0);
     }
   }
 
   void CheckStateApplyingForApplication(
-      NiceMock<application_manager_test::MockApplication>& application,
+      am::ApplicationSharedPtr app,
+      NiceMock<application_manager_test::MockApplication>& app_mock,
       std::vector<am::HmiState::StateID>& state_ids) {
     using smart_objects::SmartObject;
     using am::event_engine::Event;
     namespace FunctionID = hmi_apis::FunctionID;
 
-    EXPECT_CALL(application, CurrentHmiState())
+    EXPECT_CALL(app_mock, CurrentHmiState())
         .WillRepeatedly(Return(NoneNotAudibleState()));
 
     for (uint32_t i = 0; i < state_ids.size(); ++i) {
       am::HmiState::StateID state_id = state_ids[i];
-      EXPECT_CALL(application,
-                  AddHMIState(Truly(HmiStatesIDComparator(state_id)))).Times(1);
+      EXPECT_CALL(app_mock, AddHMIState(Truly(HmiStatesIDComparator(state_id))))
+          .Times(1);
 
       switch (state_id) {
         case am::HmiState::StateID::STATE_ID_VR_SESSION: {
@@ -1179,24 +1181,24 @@ class StateControllerImplTest : public ::testing::Test {
           state_ctrl_->on_event(emergency_event);
           break;
         }
-        case am::HmiState::StateID::STATE_ID_VIDEO_STREAMING: {
-          state_ctrl_->OnNaviStreamingStarted();
+        case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
+          state_ctrl_->OnVideoStreamingStarted(app);
           break;
         }
         default:
           break;
       }
 
-      EXPECT_CALL(application, AddHMIState(_)).Times(0);
+      EXPECT_CALL(app_mock, AddHMIState(_)).Times(0);
     }
 
     for (uint32_t i = 0; i < state_ids.size(); ++i) {
       am::HmiState::StateID state_id = state_ids[i];
-      EXPECT_CALL(application, RemoveHMIState(state_id)).Times(1);
+      EXPECT_CALL(app_mock, RemoveHMIState(state_id)).Times(1);
 
-      EXPECT_CALL(application, PostponedHmiState())
+      EXPECT_CALL(app_mock, PostponedHmiState())
           .WillOnce(Return(NoneNotAudibleState()));
-      EXPECT_CALL(application, RemovePostponedState());
+      EXPECT_CALL(app_mock, RemovePostponedState());
 
       switch (state_id) {
         case am::HmiState::StateID::STATE_ID_VR_SESSION: {
@@ -1231,15 +1233,15 @@ class StateControllerImplTest : public ::testing::Test {
           state_ctrl_->on_event(emergency_event);
           break;
         }
-        case am::HmiState::StateID::STATE_ID_VIDEO_STREAMING: {
-          state_ctrl_->OnNaviStreamingStopped();
+        case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: {
+          state_ctrl_->OnVideoStreamingStopped(app);
           break;
         }
         default:
           break;
       }
 
-      EXPECT_CALL(application, RemoveHMIState(_)).Times(0);
+      EXPECT_CALL(app_mock, RemoveHMIState(_)).Times(0);
     }
   }
 };
@@ -2046,42 +2048,48 @@ TEST_F(StateControllerImplTest, ActivateAppInvalidCorrelationId) {
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForSimpleApp) {
   InsertApplication(simple_app_);
-  CheckStateApplyingForApplication(*simple_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      simple_app_, *simple_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForMediaApp) {
   InsertApplication(media_app_);
-  CheckStateApplyingForApplication(*media_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      media_app_, *media_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForNaviApp) {
   InsertApplication(navi_app_);
-  CheckStateApplyingForApplication(*navi_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(navi_app_, *navi_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForVCApp) {
   InsertApplication(vc_app_);
-  CheckStateApplyingForApplication(*vc_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(vc_app_, *vc_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviApp) {
   InsertApplication(media_navi_app_);
-  CheckStateApplyingForApplication(*media_navi_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      media_navi_app_, *media_navi_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForMediaVCApp) {
   InsertApplication(media_vc_app_);
-  CheckStateApplyingForApplication(*media_vc_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      media_vc_app_, *media_vc_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForNaviVCApp) {
   InsertApplication(navi_vc_app_);
-  CheckStateApplyingForApplication(*navi_vc_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      navi_vc_app_, *navi_vc_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, ApplyTempStatesForMediaNaviVCApp) {
   InsertApplication(media_navi_vc_app_);
-  CheckStateApplyingForApplication(*media_navi_vc_app_ptr_, valid_state_ids_);
+  CheckStateApplyingForApplication(
+      media_navi_vc_app_, *media_navi_vc_app_ptr_, valid_state_ids_);
 }
 
 TEST_F(StateControllerImplTest, SetStatePhoneCallForNonMediaApplication) {
@@ -2969,7 +2977,8 @@ TEST_F(StateControllerImplTest, IsStateActive) {
 
 TEST_F(StateControllerImplTest, IsStateActiveApplyCorrectTempStates) {
   InsertApplication(simple_app_);
-  ApplyTempStatesForApplication(*simple_app_ptr_, valid_state_ids_);
+  ApplyTempStatesForApplication(
+      simple_app_, *simple_app_ptr_, valid_state_ids_);
   std::vector<am::HmiState::StateID>::const_iterator it =
       valid_state_ids_.begin();
   for (; it != valid_state_ids_.end(); ++it) {
diff --git a/src/components/include/application_manager/state_controller.h b/src/components/include/application_manager/state_controller.h
index a278a84de2..8f608488e9 100644
--- a/src/components/include/application_manager/state_controller.h
+++ b/src/components/include/application_manager/state_controller.h
@@ -85,9 +85,17 @@ class StateController {
   virtual int64_t SendBCActivateApp(ApplicationConstSharedPtr app,
                                     hmi_apis::Common_HMILevel::eType level,
                                     bool send_policy_priority) = 0;
+  /**
+   * @brief OnVideoStreamingStarted process video streaming started
+   * @param app projection or navigation application starting streaming
+   */
+  virtual void OnVideoStreamingStarted(ApplicationConstSharedPtr app) = 0;
 
-  virtual void OnNaviStreamingStarted() = 0;
-  virtual void OnNaviStreamingStopped() = 0;
+  /**
+   * @brief OnVideoStreamingStopped process video streaming stopped
+   * @param app projection or navigation application stopping streaming
+   */
+  virtual void OnVideoStreamingStopped(ApplicationConstSharedPtr app) = 0;
   virtual void OnStateChanged(ApplicationSharedPtr app,
                               HmiStatePtr old_state,
                               HmiStatePtr new_state) = 0;
diff --git a/src/components/include/test/application_manager/mock_state_controller.h b/src/components/include/test/application_manager/mock_state_controller.h
index 4a4dc98d17..0165180a0a 100644
--- a/src/components/include/test/application_manager/mock_state_controller.h
+++ b/src/components/include/test/application_manager/mock_state_controller.h
@@ -87,8 +87,10 @@ class MockStateController : public am::StateController {
                int64_t(am::ApplicationConstSharedPtr app,
                        hmi_apis::Common_HMILevel::eType level,
                        bool send_policy_priority));
-  MOCK_METHOD0(OnNaviStreamingStarted, void());
-  MOCK_METHOD0(OnNaviStreamingStopped, void());
+  MOCK_METHOD1(OnVideoStreamingStarted,
+               void(am::ApplicationConstSharedPtr app));
+  MOCK_METHOD1(OnVideoStreamingStopped,
+               void(am::ApplicationConstSharedPtr app));
   MOCK_METHOD3(OnStateChanged,
                void(am::ApplicationSharedPtr app,
                     am::HmiStatePtr old_state,