diff options
9 files changed, 369 insertions, 260 deletions
diff --git a/src/components/application_manager/include/application_manager/application_impl.h b/src/components/application_manager/include/application_manager/application_impl.h index 5cf44a6c94..70f2f49dad 100644 --- a/src/components/application_manager/include/application_manager/application_impl.h +++ b/src/components/application_manager/include/application_manager/application_impl.h @@ -265,7 +265,7 @@ class ApplicationImpl : public virtual Application, * * @return true if application is media, voice communication or navigation */ - virtual bool IsAudioApplication() const; + bool IsAudioApplication() const OVERRIDE; bool IsVideoApplication() const OVERRIDE; 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 6181d76aa6..342d3e3d38 100644 --- a/src/components/application_manager/include/application_manager/hmi_state.h +++ b/src/components/application_manager/include/application_manager/hmi_state.h @@ -33,6 +33,7 @@ #ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_HMI_STATE_H_ #define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_HMI_STATE_H_ +#include <iosfwd> #include <list> #include "interfaces/MOBILE_API.h" #include "utils/shared_ptr.h" @@ -53,6 +54,8 @@ typedef utils::SharedPtr<HmiState> HmiStatePtr; * */ class HmiState { + friend std::ostream& operator<<(std::ostream& os, const HmiState& src); + public: /** * @brief The StateID enum describes state of application @@ -66,7 +69,7 @@ class HmiState { STATE_ID_SAFETY_MODE, STATE_ID_VR_SESSION, STATE_ID_TTS_SESSION, - STATE_ID_NAVI_STREAMING, + STATE_ID_VIDEO_STREAMING, STATE_ID_DEACTIVATE_HMI, STATE_ID_AUDIO_SOURCE, STATE_ID_EMBEDDED_NAVI @@ -289,16 +292,16 @@ class TTSHmiState : public HmiState { }; /** - * @brief The NaviStreamingState class implements logic of NaviStreaming + * @brief The VideoStreamingState class implements logic of video streaming * temporary state */ -class NaviStreamingHmiState : public HmiState { +class VideoStreamingHmiState : public HmiState { public: - NaviStreamingHmiState(utils::SharedPtr<Application> app, - const ApplicationManager& app_mngr); + VideoStreamingHmiState(utils::SharedPtr<Application> app, + const ApplicationManager& app_mngr); - DEPRECATED NaviStreamingHmiState(uint32_t app_id, - const ApplicationManager& app_mngr); + DEPRECATED VideoStreamingHmiState(uint32_t app_id, + const ApplicationManager& app_mngr); mobile_apis::AudioStreamingState::eType audio_streaming_state() const OVERRIDE; @@ -409,5 +412,10 @@ class EmbeddedNavi : public HmiState { return mobile_apis::AudioStreamingState::NOT_AUDIBLE; } }; -} + +std::ostream& operator<<(std::ostream& os, const HmiState::StateID src); +std::ostream& operator<<(std::ostream& os, const HmiState& src); + +} // namespace application_manager + #endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_HMI_STATE_H_ 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 6e199cb5c5..9ecb7bfea9 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 @@ -191,11 +191,11 @@ class StateControllerImpl : public event_engine::EventObserver, * Move other application to HmiStates if applied moved to FULL or LIMITED */ struct HmiLevelConflictResolver { - ApplicationSharedPtr applied_; - HmiStatePtr state_; + const ApplicationSharedPtr applied_; + const HmiStatePtr state_; StateControllerImpl* state_ctrl_; - HmiLevelConflictResolver(ApplicationSharedPtr app, - HmiStatePtr state, + HmiLevelConflictResolver(const ApplicationSharedPtr app, + const HmiStatePtr state, StateControllerImpl* state_ctrl) : applied_(app), state_(state), state_ctrl_(state_ctrl) {} void operator()(ApplicationSharedPtr to_resolve); @@ -361,15 +361,6 @@ class StateControllerImpl : public event_engine::EventObserver, void SetupRegularHmiState(ApplicationSharedPtr app, HmiStatePtr state); /** - * @brief IsSameAppType checks if apps has same types - * @param app1 - * @param app2 - * @return true if aps have same types, otherwise return false - */ - bool IsSameAppType(ApplicationConstSharedPtr app1, - ApplicationConstSharedPtr app2); - - /** * @brief SetupRegularHmiState set regular HMI State without * resolving conflicts and ActivateApp request * @param app application @@ -441,7 +432,7 @@ class StateControllerImpl : public event_engine::EventObserver, typedef std::list<HmiState::StateID> StateIDList; StateIDList active_states_; mutable sync_primitives::Lock active_states_lock_; - std::map<uint32_t, HmiStatePtr> waiting_for_activate; + std::map<uint32_t, HmiStatePtr> waiting_for_activate_; ApplicationManager& app_mngr_; }; } diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc index ace7d55860..8fb88ad5ff 100644 --- a/src/components/application_manager/src/application_impl.cc +++ b/src/components/application_manager/src/application_impl.cc @@ -230,12 +230,26 @@ void ApplicationImpl::set_voice_communication_supported( } bool ApplicationImpl::IsAudioApplication() const { - return is_media_ || is_voice_communication_application_ || is_navi_ || - mobile_projection_enabled_; + const bool is_audio_app = + is_media_application() || is_voice_communication_supported() || is_navi(); + LOG4CXX_DEBUG(logger_, + std::boolalpha << "is audio app --> ((is_media_app: " + << is_media_application() << ")" + << " || (is_voice_communication_app: " + << is_voice_communication_supported() << ")" + << " || (is_navi: " << is_navi() << ")) --> " + << is_audio_app); + return is_audio_app; } bool ApplicationImpl::IsVideoApplication() const { - return is_navi_ || mobile_projection_enabled_; + const bool is_video_app = is_navi() || mobile_projection_enabled(); + LOG4CXX_DEBUG(logger_, + std::boolalpha + << "is video app --> ((is_navi: " << is_navi() << ")" + << " || (mobile_projection: " << mobile_projection_enabled() + << ")) --> " << is_video_app); + return is_video_app; } void ApplicationImpl::SetRegularState(HmiStatePtr state) { diff --git a/src/components/application_manager/src/hmi_state.cc b/src/components/application_manager/src/hmi_state.cc index 17cbdb429d..14cee28f91 100644 --- a/src/components/application_manager/src/hmi_state.cc +++ b/src/components/application_manager/src/hmi_state.cc @@ -32,6 +32,9 @@ */ #include "application_manager/hmi_state.h" +#include <ostream> +#include <boost/assign.hpp> +#include <boost/bimap.hpp> #include "application_manager/application_manager.h" #include "utils/helpers.h" @@ -65,6 +68,7 @@ DEPRECATED HmiState::HmiState(uint32_t app_id, , app_mngr_(app_mngr) , hmi_level_(mobile_apis::HMILevel::INVALID_ENUM) , audio_streaming_state_(mobile_apis::AudioStreamingState::INVALID_ENUM) + , video_streaming_state_(mobile_apis::VideoStreamingState::INVALID_ENUM) , system_context_(mobile_apis::SystemContext::INVALID_ENUM) { app_ = app_mngr_.application(app_id); } @@ -75,6 +79,7 @@ DEPRECATED HmiState::HmiState(uint32_t app_id, , app_mngr_(app_mngr) , hmi_level_(mobile_apis::HMILevel::INVALID_ENUM) , audio_streaming_state_(mobile_apis::AudioStreamingState::INVALID_ENUM) + , video_streaming_state_(mobile_apis::VideoStreamingState::INVALID_ENUM) , system_context_(mobile_apis::SystemContext::INVALID_ENUM) { app_ = app_mngr_.application(app_id); } @@ -134,43 +139,46 @@ mobile_apis::AudioStreamingState::eType TTSHmiState::audio_streaming_state() hmi_level(), HMILevel::HMI_FULL, HMILevel::HMI_LIMITED)) { expected_state = AudioStreamingState::ATTENUATED; } + return expected_state; } -NaviStreamingHmiState::NaviStreamingHmiState(utils::SharedPtr<Application> app, - const ApplicationManager& app_mngr) - : HmiState(app, app_mngr, STATE_ID_NAVI_STREAMING) {} +VideoStreamingHmiState::VideoStreamingHmiState( + utils::SharedPtr<Application> app, const ApplicationManager& app_mngr) + : HmiState(app, app_mngr, STATE_ID_VIDEO_STREAMING) {} -DEPRECATED NaviStreamingHmiState::NaviStreamingHmiState( +DEPRECATED VideoStreamingHmiState::VideoStreamingHmiState( uint32_t app_id, const ApplicationManager& app_mngr) - : HmiState(app_id, app_mngr, STATE_ID_NAVI_STREAMING) {} + : HmiState(app_id, app_mngr, STATE_ID_VIDEO_STREAMING) {} mobile_apis::AudioStreamingState::eType -NaviStreamingHmiState::audio_streaming_state() const { +VideoStreamingHmiState::audio_streaming_state() const { using namespace helpers; using namespace mobile_apis; AudioStreamingState::eType expected_state = parent()->audio_streaming_state(); - if (!is_navi_app() && AudioStreamingState::AUDIBLE == expected_state) { + if (!app_->IsVideoApplication() && + Compare<AudioStreamingState::eType, EQ, ONE>( + expected_state, + AudioStreamingState::AUDIBLE, + AudioStreamingState::ATTENUATED)) { if (app_mngr_.is_attenuated_supported()) { expected_state = AudioStreamingState::ATTENUATED; } else { expected_state = AudioStreamingState::NOT_AUDIBLE; } } + return expected_state; } mobile_apis::VideoStreamingState::eType -NaviStreamingHmiState::video_streaming_state() const { - using namespace helpers; - using namespace mobile_apis; - - VideoStreamingState::eType expected_state = parent()->video_streaming_state(); - if (!is_navi_app() && VideoStreamingState::STREAMABLE == expected_state) { - expected_state = VideoStreamingState::NOT_STREAMABLE; +VideoStreamingHmiState::video_streaming_state() const { + if (app_->IsVideoApplication()) { + return parent()->video_streaming_state(); } - return expected_state; + + return mobile_apis::VideoStreamingState::NOT_STREAMABLE; } PhoneCallHmiState::PhoneCallHmiState(utils::SharedPtr<Application> app, @@ -222,6 +230,7 @@ mobile_apis::HMILevel::eType DeactivateHMI::hmi_level() const { HMILevel::HMI_NONE)) { return parent()->hmi_level(); } + return HMILevel::HMI_BACKGROUND; } @@ -234,20 +243,13 @@ DEPRECATED AudioSource::AudioSource(uint32_t app_id, : HmiState(app_id, app_mngr, STATE_ID_AUDIO_SOURCE) {} mobile_apis::HMILevel::eType AudioSource::hmi_level() const { - using namespace mobile_apis; - using namespace helpers; - // TODO(AOleynik): That NONE check is necessary to avoid issue during + // Checking for NONE is necessary to avoid issue during // calculation of HMI level during setting default HMI level - // Should be investigated (used in multiple places here), since looks weird - if (Compare<HMILevel::eType, EQ, ONE>(parent()->hmi_level(), - HMILevel::HMI_BACKGROUND, - HMILevel::HMI_NONE)) { - return parent()->hmi_level(); - } - if (is_navi_app() || is_voice_communication_app()) { - return HMILevel::HMI_LIMITED; + if (mobile_apis::HMILevel::HMI_NONE == parent()->hmi_level()) { + return mobile_apis::HMILevel::HMI_NONE; } - return HMILevel::HMI_BACKGROUND; + + return mobile_apis::HMILevel::HMI_BACKGROUND; } EmbeddedNavi::EmbeddedNavi(utils::SharedPtr<Application> app, @@ -271,4 +273,43 @@ mobile_apis::HMILevel::eType EmbeddedNavi::hmi_level() const { } return HMILevel::HMI_BACKGROUND; } + +namespace { +typedef boost::bimap<HmiState::StateID, std::string> StateID2StrMap; +const StateID2StrMap kStateID2StrMap = + boost::assign::list_of<StateID2StrMap::relation>( + HmiState::StateID::STATE_ID_CURRENT, "CURRENT")( + HmiState::StateID::STATE_ID_REGULAR, "REGULAR")( + HmiState::StateID::STATE_ID_POSTPONED, "POSTPONED")( + HmiState::StateID::STATE_ID_PHONE_CALL, "PHONE_CALL")( + HmiState::StateID::STATE_ID_SAFETY_MODE, "SAFETY_MODE")( + 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_DEACTIVATE_HMI, "DEACTIVATE_HMI")( + HmiState::StateID::STATE_ID_AUDIO_SOURCE, "AUDIO_SOURCE")( + HmiState::StateID::STATE_ID_EMBEDDED_NAVI, "EMBEDDED_NAVI"); +} // anonymous namespace + +std::ostream& operator<<(std::ostream& os, const HmiState::StateID src) { + try { + os << kStateID2StrMap.left.at(src); + } catch (const std::exception&) { + // specified element have NOT been found + os << "UNRECOGNIZED(" << static_cast<int>(src) << ")"; + } + + return os; +} + +std::ostream& operator<<(std::ostream& os, const HmiState& src) { + os << "HMIState(app id:" << src.app_->app_id() << ", state:" << src.state_id() + << ", hmi_level:" << src.hmi_level() + << ", audio:" << src.audio_streaming_state() + << ", video:" << src.video_streaming_state() + << ", context:" << src.system_context() << ')'; + + return os; } + +} // namespace application_manager diff --git a/src/components/application_manager/src/state_controller_impl.cc b/src/components/application_manager/src/state_controller_impl.cc index 321de77d8d..9ca8680d09 100644 --- a/src/components/application_manager/src/state_controller_impl.cc +++ b/src/components/application_manager/src/state_controller_impl.cc @@ -31,6 +31,7 @@ */ #include "application_manager/state_controller_impl.h" +#include <tuple> #include "application_manager/usage_statistics.h" #include "utils/helpers.h" #include "utils/make_shared.h" @@ -40,20 +41,18 @@ namespace application_manager { CREATE_LOGGERPTR_GLOBAL(logger_, "StateControllerImpl") -bool IsStatusChanged(HmiStatePtr old_state, HmiStatePtr new_state) { - bool level_changed = old_state->hmi_level() != new_state->hmi_level(); - bool audio_streaming_state_changed = - old_state->audio_streaming_state() != new_state->audio_streaming_state(); - bool video_streaming_state_changed = - old_state->video_streaming_state() != new_state->video_streaming_state(); - bool system_context_changed = - old_state->system_context() != new_state->system_context(); - if (level_changed || audio_streaming_state_changed || - video_streaming_state_changed || system_context_changed) { - return true; - } - return false; +namespace { +bool IsStateChanged(const HmiState& old_state, const HmiState& new_state) { + return std::make_tuple(old_state.hmi_level(), + old_state.audio_streaming_state(), + old_state.video_streaming_state(), + old_state.system_context()) != + std::make_tuple(new_state.hmi_level(), + new_state.audio_streaming_state(), + new_state.video_streaming_state(), + new_state.system_context()); } +} // unnamed namespace StateControllerImpl::StateControllerImpl(ApplicationManager& app_mngr) : EventObserver(app_mngr.event_dispatcher()), app_mngr_(app_mngr) { @@ -107,7 +106,7 @@ void StateControllerImpl::SetRegularState(ApplicationSharedPtr app, if (-1 != corr_id) { subscribe_on_event(hmi_apis::FunctionID::BasicCommunication_ActivateApp, corr_id); - waiting_for_activate[app->app_id()] = resolved_state; + waiting_for_activate_[app->app_id()] = resolved_state; return; } LOG4CXX_ERROR(logger_, "Unable to send BC.ActivateApp"); @@ -268,85 +267,177 @@ void StateControllerImpl::SetRegularState(ApplicationSharedPtr app, } } -void StateControllerImpl::HmiLevelConflictResolver::operator()( - ApplicationSharedPtr to_resolve) { - using namespace mobile_apis; +namespace { + +/** + * @brief IsStreamableHMILevel checks whether the HMI level + * supports audio/video streaming. + * @param val HMI level + * @return true if streamable, false otherwise + */ +bool IsStreamableHMILevel(mobile_apis::HMILevel::eType val) { using namespace helpers; + return Compare<mobile_apis::HMILevel::eType, EQ, ONE>( + val, mobile_apis::HMILevel::HMI_FULL, mobile_apis::HMILevel::HMI_LIMITED); +} + +/** + * @brief IsSameAudioAppType checks whether the both applications: + * 1) belongs to exact HMI type that may stream audio without + * 'isMediaApplication' parameter set to true ('NAVIGATION', 'COMMUNICATION') + * 2) belongs to other HMI types with parameter 'isMediaApplication' + * is set to true. + * 3) are not media. + * @param app1 1st application + * @param app2 2nd application + * @return true if audio applications have same application HMI type + */ +bool IsSameAudioAppType(const Application& app1, const Application& app2) { + const auto is_only_media_app_type = [](const Application& app) { + return app.is_media_application() && !app.is_navi() && + !app.is_voice_communication_supported(); + }; + + const bool both_navi = app1.is_navi() && app2.is_navi(); + const bool both_vc = app1.is_voice_communication_supported() && + app2.is_voice_communication_supported(); + const bool both_media = + is_only_media_app_type(app1) && is_only_media_app_type(app2); + const bool both_other = + !app1.IsAudioApplication() && !app2.IsAudioApplication(); + const bool same_app_audio_type = + both_navi || both_vc || both_media || both_other; + + return same_app_audio_type; +} +} // unnamed namespace + +void StateControllerImpl::HmiLevelConflictResolver::operator()( + ApplicationSharedPtr app_to_resolve) { + DCHECK_OR_RETURN_VOID(app_to_resolve); DCHECK_OR_RETURN_VOID(state_ctrl_); - if (to_resolve == applied_) + DCHECK_OR_RETURN_VOID(applied_); + DCHECK_OR_RETURN_VOID(state_); + + if (applied_ == app_to_resolve) { + // Same app. Nothing to resolve return; - HmiStatePtr cur_state = to_resolve->RegularHmiState(); - - const bool applied_grabs_audio = - Compare<HMILevel::eType, EQ, ONE>( - state_->hmi_level(), HMILevel::HMI_FULL, HMILevel::HMI_LIMITED) && - applied_->IsAudioApplication(); - const bool applied_grabs_full = state_->hmi_level() == HMILevel::HMI_FULL; - const bool to_resolve_handles_full = - cur_state->hmi_level() == HMILevel::HMI_FULL; - const bool to_resolve_handles_audio = - Compare<HMILevel::eType, EQ, ONE>( - cur_state->hmi_level(), HMILevel::HMI_FULL, HMILevel::HMI_LIMITED) && - to_resolve->IsAudioApplication(); - const bool same_app_type = state_ctrl_->IsSameAppType(applied_, to_resolve); - - // If applied Hmi state is FULL: - // all not audio applications will get BACKGROUND - // all applications with same HMI type will get BACKGROUND - // all audio applications with other HMI type(navi, vc, media) in FULL will - // get LIMMITED HMI level - - // If applied Hmi state is LIMITED: - // all applications with other HMI types will save HMI states - // all not audio applications will save HMI states - // all applications with same HMI type will get BACKGROUND - - // If applied Hmi state is BACKGROUND: - // all applications will save HMI states - - HMILevel::eType result_hmi_level = cur_state->hmi_level(); - if (applied_grabs_full && to_resolve_handles_audio && !same_app_type) - result_hmi_level = HMILevel::HMI_LIMITED; - - if ((applied_grabs_full && to_resolve_handles_full && - !to_resolve->IsAudioApplication()) || - (applied_grabs_audio && to_resolve_handles_audio && same_app_type)) - result_hmi_level = HMILevel::HMI_BACKGROUND; - - if (cur_state->hmi_level() != result_hmi_level) { + } + + const HmiStatePtr state_to_resolve = app_to_resolve->RegularHmiState(); + DCHECK_OR_RETURN_VOID(state_to_resolve); + + // If applied HMI state is FULL: + // - all NOT audio/video applications becomes BACKGROUND + // - all audio/video applications with other app type + // (navi, vc, media, projection) in FULL becomes LIMMITED + // - all audio/video applications with same app type becomes BACKGROUND + // + // If applied HMI state is LIMITED: + // - all NOT audio/video applications saves their's HMI states + // - all applications with other app types saves their's HMI states + // - all audio/video applications with same app type becomes BACKGROUND + + if (!IsStreamableHMILevel(state_->hmi_level())) { + LOG4CXX_DEBUG(logger_, + "Applied for app " << applied_->app_id() << " HMI level " + << state_->hmi_level() + << " is NOT streamable. Exit."); + return; + } + + if (!IsStreamableHMILevel(state_to_resolve->hmi_level())) { + LOG4CXX_DEBUG(logger_, + "To resolve app " << app_to_resolve->app_id() << " HMI level " + << state_to_resolve->hmi_level() + << " is NOT streamable. Exit."); + return; + } + + // Applied app constants + const auto applied_hmi_level = state_->hmi_level(); + + const bool applied_grabs_video = + IsStreamableHMILevel(applied_hmi_level) && applied_->IsVideoApplication(); + + // App to resolve constants + const auto to_resolve_hmi_level = state_to_resolve->hmi_level(); + + const bool to_resolve_grabs_audio = + IsStreamableHMILevel(to_resolve_hmi_level) && + app_to_resolve->IsAudioApplication(); + + const bool to_resolve_grabs_video = + IsStreamableHMILevel(to_resolve_hmi_level) && + app_to_resolve->IsVideoApplication(); + + // Compatibility constants + const bool same_app_audio_type = + IsSameAudioAppType(*applied_, *app_to_resolve); + + // Result variables + mobile_apis::VideoStreamingState::eType result_video_state = + mobile_apis::VideoStreamingState::NOT_STREAMABLE; + mobile_apis::AudioStreamingState::eType result_audio_state = + mobile_apis::AudioStreamingState::NOT_AUDIBLE; + + if (to_resolve_grabs_audio && !same_app_audio_type) { + result_audio_state = mobile_apis::AudioStreamingState::AUDIBLE; + } + + if (to_resolve_grabs_video && !applied_grabs_video) { + result_video_state = mobile_apis::VideoStreamingState::STREAMABLE; + } + + mobile_apis::HMILevel::eType result_hmi_level = state_to_resolve->hmi_level(); + + if (mobile_apis::HMILevel::HMI_FULL == applied_hmi_level) { + using namespace helpers; + if (mobile_apis::VideoStreamingState::STREAMABLE == result_video_state || + Compare<mobile_apis::AudioStreamingState::eType, EQ, ONE>( + result_audio_state, + mobile_apis::AudioStreamingState::AUDIBLE, + mobile_apis::AudioStreamingState::ATTENUATED)) { + result_hmi_level = mobile_apis::HMILevel::HMI_LIMITED; + } else { + result_hmi_level = mobile_apis::HMILevel::HMI_BACKGROUND; + } + } else if (mobile_apis::HMILevel::HMI_LIMITED == applied_hmi_level) { + if (to_resolve_hmi_level == applied_hmi_level) { + result_hmi_level = mobile_apis::HMILevel::HMI_BACKGROUND; + } + } + + if (std::make_tuple(to_resolve_hmi_level, + state_to_resolve->audio_streaming_state(), + state_to_resolve->video_streaming_state()) != + std::make_tuple( + result_hmi_level, result_audio_state, result_video_state)) { LOG4CXX_DEBUG(logger_, - "Application " << to_resolve->app_id() - << " will change HMI level to " - << result_hmi_level); - VideoStreamingState::eType video_state = - result_hmi_level == HMILevel::HMI_LIMITED - ? VideoStreamingState::STREAMABLE - : VideoStreamingState::NOT_STREAMABLE; - AudioStreamingState::eType audio_state = - result_hmi_level == HMILevel::HMI_LIMITED - ? AudioStreamingState::AUDIBLE - : AudioStreamingState::NOT_AUDIBLE; - - state_ctrl_->SetupRegularHmiState( - to_resolve, result_hmi_level, audio_state, video_state); + "Application " + << app_to_resolve->app_id() << " will change state to: " + << "HMI level " << to_resolve_hmi_level << " --> " + << result_hmi_level << ", audio " + << state_to_resolve->audio_streaming_state() << " --> " + << result_audio_state << ", video " + << state_to_resolve->video_streaming_state() << " --> " + << result_video_state); + state_ctrl_->SetupRegularHmiState(app_to_resolve, + result_hmi_level, + result_audio_state, + result_video_state); } else { LOG4CXX_DEBUG(logger_, - "Application " << to_resolve->app_id() - << " will not change HMI level"); + "Application " << app_to_resolve->app_id() + << " will NOT change HMI level"); } } HmiStatePtr StateControllerImpl::ResolveHmiState(ApplicationSharedPtr app, HmiStatePtr state) const { using namespace mobile_apis; - using namespace helpers; LOG4CXX_AUTO_TRACE(logger_); - LOG4CXX_DEBUG(logger_, - "State to resolve: hmi_level " - << state->hmi_level() << ", audio_state " - << state->video_streaming_state() << ", video_state " - << state->audio_streaming_state() << ", system_context " - << state->system_context()); + LOG4CXX_DEBUG(logger_, "State to resolve: " << *state); HmiStatePtr available_state = CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR); @@ -372,11 +463,8 @@ HmiStatePtr StateControllerImpl::ResolveHmiState(ApplicationSharedPtr app, bool StateControllerImpl::IsResumptionAllowed(ApplicationSharedPtr app, HmiStatePtr state) const { LOG4CXX_AUTO_TRACE(logger_); - using namespace helpers; using namespace mobile_apis; - if (!app->is_resuming() || - !Compare<HMILevel::eType, EQ, ONE>( - state->hmi_level(), HMILevel::HMI_FULL, HMILevel::HMI_LIMITED)) { + if (!app->is_resuming() || !IsStreamableHMILevel(state->hmi_level())) { LOG4CXX_DEBUG(logger_, "Application is not in resuming mode."); return true; } @@ -402,20 +490,17 @@ bool StateControllerImpl::IsResumptionAllowed(ApplicationSharedPtr app, mobile_apis::HMILevel::eType StateControllerImpl::GetAvailableHmiLevel( ApplicationSharedPtr app, mobile_apis::HMILevel::eType hmi_level) const { - using namespace mobile_apis; - using namespace helpers; LOG4CXX_AUTO_TRACE(logger_); mobile_apis::HMILevel::eType result = hmi_level; - if (!Compare<HMILevel::eType, EQ, ONE>( - hmi_level, HMILevel::HMI_FULL, HMILevel::HMI_LIMITED)) { + if (!IsStreamableHMILevel(hmi_level)) { return result; } const bool is_audio_app = app->IsAudioApplication(); const bool does_audio_app_with_same_type_exist = app_mngr_.IsAppTypeExistsInFullOrLimited(app); - if (HMILevel::HMI_LIMITED == hmi_level) { + if (mobile_apis::HMILevel::HMI_LIMITED == hmi_level) { if (!is_audio_app || does_audio_app_with_same_type_exist) { result = app_mngr_.GetDefaultHmiLevel(app); } @@ -451,13 +536,8 @@ mobile_apis::HMILevel::eType StateControllerImpl::GetAvailableHmiLevel( bool StateControllerImpl::IsStateAvailable(ApplicationSharedPtr app, HmiStatePtr state) const { using namespace mobile_apis; - using namespace helpers; LOG4CXX_AUTO_TRACE(logger_); - LOG4CXX_DEBUG(logger_, - "Checking state: hmi_level " - << state->hmi_level() << ", audio_state " - << state->audio_streaming_state() << ", system_context " - << state->system_context()); + LOG4CXX_DEBUG(logger_, "Checking state: " << *state); if (app->is_resuming()) { return IsStateAvailableForResumption(app, state); @@ -481,11 +561,8 @@ bool StateControllerImpl::IsStateAvailableForResumption( ApplicationSharedPtr app, HmiStatePtr state) const { LOG4CXX_AUTO_TRACE(logger_); using namespace mobile_apis; - using namespace helpers; - if (!app->is_resuming() || - !Compare<HMILevel::eType, EQ, ONE>( - state->hmi_level(), HMILevel::HMI_FULL, HMILevel::HMI_LIMITED)) { + if (!app->is_resuming() || !IsStreamableHMILevel(state->hmi_level())) { LOG4CXX_DEBUG(logger_, "Application is not in resuming mode." << " Requested state is available"); @@ -519,14 +596,10 @@ bool StateControllerImpl::IsStateAvailableForResumption( void StateControllerImpl::SetupRegularHmiState(ApplicationSharedPtr app, HmiStatePtr state) { - namespace HMILevel = mobile_apis::HMILevel; - namespace AudioStreamingState = mobile_apis::AudioStreamingState; + using namespace mobile_apis; LOG4CXX_AUTO_TRACE(logger_); DCHECK_OR_RETURN_VOID(state); - LOG4CXX_DEBUG(logger_, - "hmi_level " << state->hmi_level() << ", audio_state " - << state->audio_streaming_state() - << ", system_context " << state->system_context()); + LOG4CXX_DEBUG(logger_, "Setup regular state: " << *state); HmiStatePtr curr_state = app->CurrentHmiState(); HmiStatePtr old_state = CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR); @@ -577,28 +650,12 @@ void StateControllerImpl::ApplyRegularState(ApplicationSharedPtr app, DCHECK_OR_RETURN_VOID(app); DCHECK_OR_RETURN_VOID(state); DCHECK_OR_RETURN_VOID(state->state_id() == HmiState::STATE_ID_REGULAR); + LOG4CXX_DEBUG(logger_, + "Applying to app " << app->app_id() << " state " << *state); SetupRegularHmiState(app, state); - ForEachApplication<HmiLevelConflictResolver>( - HmiLevelConflictResolver(app, state, this)); -} - -bool StateControllerImpl::IsSameAppType(ApplicationConstSharedPtr app1, - ApplicationConstSharedPtr app2) { - const bool both_media = - app1->is_media_application() && app2->is_media_application(); - - const bool both_navi = app1->is_navi() && app2->is_navi(); - - const bool both_vc = app1->is_voice_communication_supported() && - app2->is_voice_communication_supported(); - - const bool both_simple = - !app1->IsAudioApplication() && !app2->IsAudioApplication(); - - const bool both_projection = - app1->mobile_projection_enabled() && app2->mobile_projection_enabled(); - - return both_simple || both_media || both_navi || both_vc || both_projection; + LOG4CXX_DEBUG(logger_, + "Resolving HMI level conflicts for app " << app->app_id()); + ForEachApplication(HmiLevelConflictResolver(app, state, this)); } void StateControllerImpl::on_event(const event_engine::Event& event) { @@ -704,19 +761,9 @@ void StateControllerImpl::OnStateChanged(ApplicationSharedPtr app, DCHECK_OR_RETURN_VOID(app); DCHECK_OR_RETURN_VOID(old_state); DCHECK_OR_RETURN_VOID(new_state); - LOG4CXX_DEBUG(logger_, - "old: hmi_level " - << old_state->hmi_level() << ", audio_state " - << old_state->audio_streaming_state() << ", video_state " - << old_state->video_streaming_state() << ", system_context " - << old_state->system_context()); - LOG4CXX_DEBUG(logger_, - "new: hmi_level " - << new_state->hmi_level() << ", audio_state " - << new_state->audio_streaming_state() << ", video_state " - << old_state->video_streaming_state() << ", system_context " - << new_state->system_context()); - if (IsStatusChanged(old_state, new_state)) { + LOG4CXX_DEBUG(logger_, "Old state: " << *old_state); + LOG4CXX_DEBUG(logger_, "New state: " << *new_state); + if (IsStateChanged(*old_state, *new_state)) { app_mngr_.SendHMIStatusNotification(app); if (new_state->hmi_level() == mobile_apis::HMILevel::HMI_NONE) { app->ResetDataInNone(); @@ -841,14 +888,30 @@ void StateControllerImpl::DeactivateApp(ApplicationSharedPtr app) { LOG4CXX_AUTO_TRACE(logger_); DCHECK_OR_RETURN_VOID(app); - HmiStatePtr regular = app->RegularHmiState(); + const HmiStatePtr regular = app->RegularHmiState(); DCHECK_OR_RETURN_VOID(regular); HmiStatePtr new_regular = utils::MakeShared<HmiState>(*regular); - if (app->IsAudioApplication()) { + LOG4CXX_DEBUG(logger_, "Current HMI level: '" << app->hmi_level() << "'"); + const bool is_audio_app = app->IsAudioApplication(); + const bool is_video_app = app->IsVideoApplication(); + + if (is_audio_app || is_video_app) { + // audio or video app move to HMI level limited new_regular->set_hmi_level(HMILevel::HMI_LIMITED); - new_regular->set_audio_streaming_state(AudioStreamingState::AUDIBLE); - new_regular->set_video_streaming_state(VideoStreamingState::STREAMABLE); + + if (is_audio_app) { + new_regular->set_audio_streaming_state(AudioStreamingState::AUDIBLE); + } else { + new_regular->set_audio_streaming_state(AudioStreamingState::NOT_AUDIBLE); + } + + if (is_video_app) { + new_regular->set_video_streaming_state(VideoStreamingState::STREAMABLE); + } else { + new_regular->set_video_streaming_state( + VideoStreamingState::NOT_STREAMABLE); + } } else { new_regular->set_hmi_level(HMILevel::HMI_BACKGROUND); new_regular->set_audio_streaming_state(AudioStreamingState::NOT_AUDIBLE); @@ -869,7 +932,7 @@ void StateControllerImpl::OnActivateAppResponse( ApplicationSharedPtr application = app_mngr_.application_by_hmi_app(hmi_app_id); if (application && hmi_apis::Common_Result::SUCCESS == code) { - HmiStatePtr pending_state = waiting_for_activate[application->app_id()]; + HmiStatePtr pending_state = waiting_for_activate_[application->app_id()]; DCHECK_OR_RETURN_VOID(pending_state); ApplyRegularState(application, pending_state); } @@ -914,11 +977,11 @@ void StateControllerImpl::OnAppDeactivated( } void StateControllerImpl::OnNaviStreamingStarted() { - ApplyTempState<HmiState::STATE_ID_NAVI_STREAMING>(); + ApplyTempState<HmiState::STATE_ID_VIDEO_STREAMING>(); } void StateControllerImpl::OnNaviStreamingStopped() { - CancelTempState<HmiState::STATE_ID_NAVI_STREAMING>(); + CancelTempState<HmiState::STATE_ID_VIDEO_STREAMING>(); } bool StateControllerImpl::IsStateActive(HmiState::StateID state_id) const { @@ -955,8 +1018,8 @@ HmiStatePtr StateControllerImpl::CreateHmiState( new_state = MakeShared<TTSHmiState>(app, app_mngr_); break; } - case HmiState::STATE_ID_NAVI_STREAMING: { - new_state = MakeShared<NaviStreamingHmiState>(app, app_mngr_); + case HmiState::STATE_ID_VIDEO_STREAMING: { + new_state = MakeShared<VideoStreamingHmiState>(app, app_mngr_); break; } case HmiState::STATE_ID_REGULAR: { @@ -990,39 +1053,31 @@ HmiStatePtr StateControllerImpl::CreateHmiState( mobile_apis::AudioStreamingState::eType StateControllerImpl::CalcAudioState( ApplicationSharedPtr app, const mobile_apis::HMILevel::eType hmi_level) const { - namespace HMILevel = mobile_apis::HMILevel; - namespace AudioStreamingState = mobile_apis::AudioStreamingState; - using helpers::Compare; - using helpers::EQ; - using helpers::ONE; - - AudioStreamingState::eType audio_state = AudioStreamingState::NOT_AUDIBLE; - if (Compare<HMILevel::eType, EQ, ONE>( - hmi_level, HMILevel::HMI_FULL, HMILevel::HMI_LIMITED)) { - if (app->IsAudioApplication()) { - audio_state = AudioStreamingState::AUDIBLE; - } + auto state = mobile_apis::AudioStreamingState::NOT_AUDIBLE; + if (IsStreamableHMILevel(hmi_level) && app->IsAudioApplication()) { + state = mobile_apis::AudioStreamingState::AUDIBLE; } - return audio_state; + + LOG4CXX_DEBUG(logger_, + "Calculated audio state of app " + << app->app_id() << " for " << hmi_level << " HMI level is " + << state); + return state; } mobile_apis::VideoStreamingState::eType StateControllerImpl::CalcVideoState( ApplicationSharedPtr app, const mobile_apis::HMILevel::eType hmi_level) const { - namespace HMILevel = mobile_apis::HMILevel; - namespace VideoStreamingState = mobile_apis::VideoStreamingState; - using helpers::Compare; - using helpers::EQ; - using helpers::ONE; - - VideoStreamingState::eType video_state = VideoStreamingState::NOT_STREAMABLE; - if (Compare<HMILevel::eType, EQ, ONE>( - hmi_level, HMILevel::HMI_FULL, HMILevel::HMI_LIMITED)) { - if (app->IsVideoApplication()) { - video_state = VideoStreamingState::STREAMABLE; - } + auto state = mobile_apis::VideoStreamingState::NOT_STREAMABLE; + if (IsStreamableHMILevel(hmi_level) && app->IsVideoApplication()) { + state = mobile_apis::VideoStreamingState::STREAMABLE; } - return video_state; + + LOG4CXX_DEBUG(logger_, + "Calculated video state of app " + << app->app_id() << " for " << hmi_level << " HMI level is " + << state); + return state; } } // namespace application_manager diff --git a/src/components/application_manager/test/application_impl_test.cc b/src/components/application_manager/test/application_impl_test.cc index 6b7f78b8f7..be2986e719 100644 --- a/src/components/application_manager/test/application_impl_test.cc +++ b/src/components/application_manager/test/application_impl_test.cc @@ -179,7 +179,7 @@ TEST_F(ApplicationImplTest, AddStateAddRegularState_GetCurrentState) { HmiState::STATE_ID_REGULAR, &ApplicationImpl::SetRegularState); TestAddHmiState(HMILevel::HMI_LIMITED, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); CheckCurrentHMIState(); @@ -191,7 +191,7 @@ TEST_F(ApplicationImplTest, AddStateAddRegularState_GetRegularState) { HmiState::STATE_ID_REGULAR, &ApplicationImpl::SetRegularState); TestAddHmiState(HMILevel::HMI_LIMITED, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); HmiStatePtr current_state = app_impl->RegularHmiState(); @@ -206,7 +206,7 @@ TEST_F(ApplicationImplTest, AddStates_RemoveLastState) { HmiState::STATE_ID_PHONE_CALL, &ApplicationImpl::AddHMIState); HmiStatePtr state2 = TestAddHmiState(HMILevel::HMI_NONE, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED, HmiState::STATE_ID_TTS_SESSION, @@ -219,7 +219,7 @@ TEST_F(ApplicationImplTest, AddStates_RemoveLastState) { HmiStatePtr current_state = app_impl->CurrentHmiState(); EXPECT_EQ(state2, current_state); EXPECT_EQ(HMILevel::HMI_NONE, current_state->hmi_level()); - EXPECT_EQ(HmiState::STATE_ID_NAVI_STREAMING, current_state->state_id()); + EXPECT_EQ(HmiState::STATE_ID_VIDEO_STREAMING, current_state->state_id()); } TEST_F(ApplicationImplTest, AddStates_RemoveNotLastNotFirstState) { @@ -227,7 +227,7 @@ TEST_F(ApplicationImplTest, AddStates_RemoveNotLastNotFirstState) { HmiState::STATE_ID_PHONE_CALL, &ApplicationImpl::AddHMIState); HmiStatePtr state2 = TestAddHmiState(HMILevel::HMI_NONE, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED, HmiState::STATE_ID_TTS_SESSION, @@ -251,7 +251,7 @@ TEST_F(ApplicationImplTest, AddStates_RemoveFirstState) { &ApplicationImpl::AddHMIState); // Second state TestAddHmiState(HMILevel::HMI_NONE, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); HmiStatePtr state3 = TestAddHmiState(HMILevel::HMI_LIMITED, HmiState::STATE_ID_TTS_SESSION, @@ -270,7 +270,7 @@ TEST_F(ApplicationImplTest, AddStates_RemoveFirstState) { TEST_F(ApplicationImplTest, SetRegularState_RemoveFirstState) { HmiStatePtr state1 = TestAddHmiState(HMILevel::HMI_NONE, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); // Set regular state HmiStatePtr state2 = TestAddHmiState(HMILevel::HMI_FULL, @@ -321,7 +321,7 @@ TEST_F(ApplicationImplTest, AddStateAddRegularState_GetHmiLvlAudioSystemState) { audiostate = AudioStreamingState::AUDIBLE; syst_context = SystemContext::SYSCTXT_MENU; TestAddHmiState(HMILevel::HMI_LIMITED, - HmiState::STATE_ID_NAVI_STREAMING, + HmiState::STATE_ID_VIDEO_STREAMING, &ApplicationImpl::AddHMIState); EXPECT_EQ(test_lvl, app_impl->hmi_level()); diff --git a/src/components/application_manager/test/application_state_test.cc b/src/components/application_manager/test/application_state_test.cc index 33f23022f0..6f732b6adc 100644 --- a/src/components/application_manager/test/application_state_test.cc +++ b/src/components/application_manager/test/application_state_test.cc @@ -58,7 +58,7 @@ std::vector<StateID> GenerateCurrentStates() { states.push_back(StateID::STATE_ID_SAFETY_MODE); states.push_back(StateID::STATE_ID_VR_SESSION); states.push_back(StateID::STATE_ID_TTS_SESSION); - states.push_back(StateID::STATE_ID_NAVI_STREAMING); + states.push_back(StateID::STATE_ID_VIDEO_STREAMING); states.push_back(StateID::STATE_ID_DEACTIVATE_HMI); return states; } 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 f1607c1c77..16181b10b3 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_NAVI_STREAMING); + valid_state_ids_.push_back(am::HmiState::StateID::STATE_ID_VIDEO_STREAMING); } void ConfigureApps() { @@ -1120,7 +1120,7 @@ class StateControllerImplTest : public ::testing::Test { state_ctrl_->on_event(emergency_event); break; } - case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: { + case am::HmiState::StateID::STATE_ID_VIDEO_STREAMING: { state_ctrl_->OnNaviStreamingStarted(); break; } @@ -1179,7 +1179,7 @@ class StateControllerImplTest : public ::testing::Test { state_ctrl_->on_event(emergency_event); break; } - case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: { + case am::HmiState::StateID::STATE_ID_VIDEO_STREAMING: { state_ctrl_->OnNaviStreamingStarted(); break; } @@ -1231,7 +1231,7 @@ class StateControllerImplTest : public ::testing::Test { state_ctrl_->on_event(emergency_event); break; } - case am::HmiState::StateID::STATE_ID_NAVI_STREAMING: { + case am::HmiState::StateID::STATE_ID_VIDEO_STREAMING: { state_ctrl_->OnNaviStreamingStopped(); break; } @@ -2203,8 +2203,8 @@ TEST_F(StateControllerImplTest, TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(simple_app_, - app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(simple_app_, + app_manager_mock_); TestSetState(simple_app_, state_navi_streming, APP_TYPE_NON_MEDIA, @@ -2214,8 +2214,8 @@ TEST_F(StateControllerImplTest, SetNaviStreamingStateForNonMediaApplication) { TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaApplicationAttenuatedNotSupported) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(media_app_, - app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(media_app_, + app_manager_mock_); EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(false)); TestSetState(media_app_, @@ -2227,8 +2227,8 @@ TEST_F(StateControllerImplTest, TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaApplicationAttenuatedSupported) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(media_app_, - app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(media_app_, + app_manager_mock_); EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(true)); TestSetState(media_app_, @@ -2240,7 +2240,7 @@ TEST_F(StateControllerImplTest, TEST_F(StateControllerImplTest, SetNaviStreamingStateVCApplicationAttenuatedNotSupported) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(vc_app_, app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(vc_app_, app_manager_mock_); EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(false)); TestSetState(vc_app_, @@ -2252,7 +2252,7 @@ TEST_F(StateControllerImplTest, TEST_F(StateControllerImplTest, SetNaviStreamingStateVCApplicationAttenuatedSupported) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(vc_app_, app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(vc_app_, app_manager_mock_); EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(true)); TestSetState(vc_app_, @@ -2263,8 +2263,8 @@ TEST_F(StateControllerImplTest, TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(navi_app_, - app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(navi_app_, + app_manager_mock_); TestSetState(navi_app_, state_navi_streming, APP_TYPE_NAVI, @@ -2273,8 +2273,8 @@ TEST_F(StateControllerImplTest, SetNaviStreamingStateNaviApplication) { TEST_F(StateControllerImplTest, SetNaviStreamingStateMediaNaviApplication) { am::HmiStatePtr state_navi_streming = - utils::MakeShared<am::NaviStreamingHmiState>(media_navi_app_, - app_manager_mock_); + utils::MakeShared<am::VideoStreamingHmiState>(media_navi_app_, + app_manager_mock_); TestSetState(media_navi_app_, state_navi_streming, APP_TYPE_NAVI, @@ -2335,7 +2335,7 @@ TEST_F(StateControllerImplTest, EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(false)); - TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>( + TestMixState<am::PhoneCallHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PreparePhoneCallHMIStateResults); } @@ -2344,7 +2344,7 @@ TEST_F(StateControllerImplTest, EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(true)); - TestMixState<am::PhoneCallHmiState, am::NaviStreamingHmiState>( + TestMixState<am::PhoneCallHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PreparePhoneCallHMIStateResults); } @@ -2373,7 +2373,7 @@ TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedNotSupported) { EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(false)); - TestMixState<am::VRHmiState, am::NaviStreamingHmiState>( + TestMixState<am::VRHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PrepareVRTTSHMIStateResults); } @@ -2381,7 +2381,7 @@ TEST_F(StateControllerImplTest, MixNaviStreamingWithVRAttenuatedSupported) { EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(true)); - TestMixState<am::VRHmiState, am::NaviStreamingHmiState>( + TestMixState<am::VRHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PrepareVRTTSHMIStateResults); } @@ -2395,7 +2395,7 @@ TEST_F(StateControllerImplTest, EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(false)); - TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>( + TestMixState<am::TTSHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PrepareVRTTSHMIStateResults); } @@ -2403,7 +2403,7 @@ TEST_F(StateControllerImplTest, MixNaviStreamingWithTTSAttenueatedSupported) { EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(true)); - TestMixState<am::TTSHmiState, am::NaviStreamingHmiState>( + TestMixState<am::TTSHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PrepareNaviStreamTTSStateResult); } @@ -2428,7 +2428,7 @@ TEST_F(StateControllerImplTest, EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(false)); - TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>( + TestMixState<am::SafetyModeHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PrepareVRTTSHMIStateResults); } @@ -2437,7 +2437,7 @@ TEST_F(StateControllerImplTest, EXPECT_CALL(app_manager_mock_, is_attenuated_supported()) .WillRepeatedly(Return(true)); - TestMixState<am::SafetyModeHmiState, am::NaviStreamingHmiState>( + TestMixState<am::SafetyModeHmiState, am::VideoStreamingHmiState>( &StateControllerImplTest::PrepareVRTTSHMIStateResults); } |