diff options
author | Justin Dickow <jjdickow@gmail.com> | 2014-10-20 17:44:41 -0400 |
---|---|---|
committer | Justin Dickow <jjdickow@gmail.com> | 2014-10-20 17:44:41 -0400 |
commit | 34e7256493ff0e6594029b9857d7e2aa31f5dbeb (patch) | |
tree | 367306b507c52d3af211533810adbc22004e0192 /src/components/application_manager/src | |
parent | 2eef966e9b5fd4d94dd98820095eb765e200c64b (diff) | |
download | sdl_core-34e7256493ff0e6594029b9857d7e2aa31f5dbeb.tar.gz |
SDL 3.8!
Signed-off-by: Justin Dickow <jjdickow@gmail.com>
Diffstat (limited to 'src/components/application_manager/src')
336 files changed, 40643 insertions, 0 deletions
diff --git a/src/components/application_manager/src/application_data_impl.cc b/src/components/application_manager/src/application_data_impl.cc new file mode 100644 index 0000000000..56fc88ffe3 --- /dev/null +++ b/src/components/application_manager/src/application_data_impl.cc @@ -0,0 +1,504 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/application_data_impl.h" +#include "application_manager/smart_object_keys.h" + +namespace application_manager { + +InitialApplicationDataImpl::InitialApplicationDataImpl() + : app_types_(NULL), + vr_synonyms_(NULL), + mobile_app_id_(NULL), + tts_name_(NULL), + ngn_media_screen_name_(NULL), + language_(mobile_api::Language::INVALID_ENUM), + ui_language_(mobile_api::Language::INVALID_ENUM) { +} + +InitialApplicationDataImpl::~InitialApplicationDataImpl() { + if (app_types_) { + delete app_types_; + app_types_ = NULL; + } + + if (vr_synonyms_) { + delete vr_synonyms_; + vr_synonyms_ = NULL; + } + + if (mobile_app_id_) { + delete mobile_app_id_; + mobile_app_id_ = NULL; + } + + if (tts_name_) { + delete tts_name_; + tts_name_ = NULL; + } + + if (ngn_media_screen_name_) { + delete ngn_media_screen_name_; + ngn_media_screen_name_ = NULL; + } +} + +const smart_objects::SmartObject* +InitialApplicationDataImpl::app_types() const { + return app_types_; +} + +const smart_objects::SmartObject* +InitialApplicationDataImpl::vr_synonyms() const { + return vr_synonyms_; +} + +const smart_objects::SmartObject* +InitialApplicationDataImpl::mobile_app_id() const { + return mobile_app_id_; +} + +const smart_objects::SmartObject* InitialApplicationDataImpl::tts_name() const { + return tts_name_; +} + +const smart_objects::SmartObject* +InitialApplicationDataImpl::ngn_media_screen_name() const { + return ngn_media_screen_name_; +} + +const mobile_api::Language::eType& +InitialApplicationDataImpl::language() const { + return language_; +} + +const mobile_api::Language::eType& +InitialApplicationDataImpl::ui_language() const { + return ui_language_; +} + +void InitialApplicationDataImpl::set_app_types( + const smart_objects::SmartObject& app_types) { + if (app_types_) { + delete app_types_; + } + + app_types_ = new smart_objects::SmartObject(app_types); +} + +void InitialApplicationDataImpl::set_vr_synonyms( + const smart_objects::SmartObject& vr_synonyms) { + if (vr_synonyms_) { + delete vr_synonyms_; + } + vr_synonyms_ = new smart_objects::SmartObject(vr_synonyms); +} + +void InitialApplicationDataImpl::set_mobile_app_id( + const smart_objects::SmartObject& mobile_app_id) { + if (mobile_app_id_) { + delete mobile_app_id_; + } + mobile_app_id_ = new smart_objects::SmartObject(mobile_app_id); +} + +void InitialApplicationDataImpl::set_tts_name( + const smart_objects::SmartObject& tts_name) { + if (tts_name_) { + delete tts_name_; + } + + tts_name_ = new smart_objects::SmartObject(tts_name); +} + +void InitialApplicationDataImpl::set_ngn_media_screen_name( + const smart_objects::SmartObject& ngn_name) { + if (ngn_media_screen_name_) { + delete ngn_media_screen_name_; + } + + ngn_media_screen_name_ = new smart_objects::SmartObject(ngn_name); +} + +void InitialApplicationDataImpl::set_language( + const mobile_api::Language::eType& language) { + language_ = language; +} + +void InitialApplicationDataImpl::set_ui_language( + const mobile_api::Language::eType& ui_language) { + ui_language_ = ui_language; +} + +DynamicApplicationDataImpl::DynamicApplicationDataImpl() + : help_prompt_(NULL), + timeout_prompt_(NULL), + vr_help_title_(NULL), + vr_help_(NULL), + tbt_state_(mobile_api::TBTState::INVALID_ENUM), + show_command_(NULL), + keyboard_props_(NULL), + menu_title_(NULL), + menu_icon_(NULL), + tbt_show_command_(NULL), + commands_(), + sub_menu_(), + choice_set_map_(), + performinteraction_choice_set_map_(), + is_perform_interaction_active_(false), + perform_interaction_ui_corrid_(0), + is_reset_global_properties_active_(false), + perform_interaction_mode_(-1) { +} + +DynamicApplicationDataImpl::~DynamicApplicationDataImpl() { + if (help_prompt_) { + delete help_prompt_; + help_prompt_ = NULL; + } + + if (timeout_prompt_) { + delete timeout_prompt_; + timeout_prompt_ = NULL; + } + + if (vr_help_title_) { + delete vr_help_title_; + vr_help_title_ = NULL; + } + + if (vr_help_) { + delete vr_help_; + vr_help_ = NULL; + } + + if (show_command_) { + delete show_command_; + show_command_ = NULL; + } + + if (tbt_show_command_) { + delete tbt_show_command_; + tbt_show_command_ = NULL; + } + + for (CommandsMap::iterator command_it = commands_.begin(); + commands_.end() != command_it; ++command_it) { + delete command_it->second; + } + commands_.clear(); + + for (SubMenuMap::iterator sub_menu_it = sub_menu_.begin(); + sub_menu_.end() != sub_menu_it; ++sub_menu_it) { + delete sub_menu_it->second; + } + sub_menu_.clear(); + + PerformChoiceSetMap::iterator it = performinteraction_choice_set_map_.begin(); + for (; performinteraction_choice_set_map_.end() != it; ++it) { + delete it->second; + } + performinteraction_choice_set_map_.clear(); +} + +const smart_objects::SmartObject* +DynamicApplicationDataImpl::help_prompt() const { + return help_prompt_; +} + +const smart_objects::SmartObject* +DynamicApplicationDataImpl::timeout_prompt() const { + return timeout_prompt_; +} + +const smart_objects::SmartObject* +DynamicApplicationDataImpl::vr_help_title() const { + return vr_help_title_; +} + +const smart_objects::SmartObject* +DynamicApplicationDataImpl::vr_help() const { + return vr_help_; +} + +const mobile_api::TBTState::eType& +DynamicApplicationDataImpl::tbt_state() const { + return tbt_state_; +} + +const smart_objects::SmartObject* +DynamicApplicationDataImpl::show_command() const { + return show_command_; +} + +const smart_objects::SmartObject* +DynamicApplicationDataImpl::tbt_show_command() const { + return tbt_show_command_; +} + +const NsSmartDeviceLink::NsSmartObjects::SmartObject *DynamicApplicationDataImpl::keyboard_props() const { + return keyboard_props_; +} + +const NsSmartDeviceLink::NsSmartObjects::SmartObject *DynamicApplicationDataImpl::menu_title() const { + return menu_title_; +} + +const NsSmartDeviceLink::NsSmartObjects::SmartObject* DynamicApplicationDataImpl::menu_icon() const { + return menu_icon_; +} + +void DynamicApplicationDataImpl::set_help_prompt( + const smart_objects::SmartObject& help_prompt) { + if (help_prompt_) { + delete help_prompt_; + } + help_prompt_ = new smart_objects::SmartObject(help_prompt); +} + +void DynamicApplicationDataImpl::set_timeout_prompt( + const smart_objects::SmartObject& timeout_prompt) { + if (timeout_prompt_) { + delete timeout_prompt_; + } + timeout_prompt_ = new smart_objects::SmartObject(timeout_prompt); +} + +void DynamicApplicationDataImpl::set_vr_help_title( + const smart_objects::SmartObject& vr_help_title) { + if (vr_help_title_) { + delete vr_help_title_; + } + vr_help_title_ = new smart_objects::SmartObject(vr_help_title); +} + +void DynamicApplicationDataImpl::reset_vr_help_title() { + if (vr_help_title_) { + delete vr_help_title_; + vr_help_title_ = NULL; + } +} + +void DynamicApplicationDataImpl::set_vr_help( + const smart_objects::SmartObject& vr_help) { + if (vr_help_) { + delete vr_help_; + } + vr_help_ = new smart_objects::SmartObject(vr_help); +} + +void DynamicApplicationDataImpl::reset_vr_help() { + if (vr_help_) { + delete vr_help_; + } + vr_help_ = NULL; +} + +void DynamicApplicationDataImpl::set_tbt_state( + const mobile_api::TBTState::eType& tbt_state) { + tbt_state_ = tbt_state; +} + +void DynamicApplicationDataImpl::set_show_command( + const smart_objects::SmartObject& show_command) { + if (show_command_) { + delete show_command_; + } + show_command_ = new smart_objects::SmartObject(show_command); +} + +void DynamicApplicationDataImpl::set_tbt_show_command( + const smart_objects::SmartObject& tbt_show) { + if (tbt_show_command_) { + delete tbt_show_command_; + } + tbt_show_command_ = new smart_objects::SmartObject(tbt_show); +} + +void DynamicApplicationDataImpl::set_keyboard_props( + const smart_objects::SmartObject& keyboard_props) { + if (keyboard_props_) { + delete keyboard_props_; + } + keyboard_props_ = new smart_objects::SmartObject(keyboard_props); +} + +void DynamicApplicationDataImpl::set_menu_title( + const smart_objects::SmartObject& menu_title) { + if (menu_title_) { + delete menu_title_; + } + menu_title_ = new smart_objects::SmartObject(menu_title); +} + +void DynamicApplicationDataImpl::set_menu_icon( + const smart_objects::SmartObject& menu_icon) { + if (menu_icon_) { + delete menu_icon_; + } + menu_icon_= new smart_objects::SmartObject(menu_icon); +} + + +void DynamicApplicationDataImpl::AddCommand( + uint32_t cmd_id, const smart_objects::SmartObject& command) { + commands_[cmd_id] = new smart_objects::SmartObject(command); +} + +void DynamicApplicationDataImpl::RemoveCommand(uint32_t cmd_id) { + CommandsMap::iterator it = commands_.find(cmd_id); + + if (commands_.end() != it) { + delete it->second; + commands_.erase(it); + } +} + +smart_objects::SmartObject* DynamicApplicationDataImpl::FindCommand( + uint32_t cmd_id) { + CommandsMap::const_iterator it = commands_.find(cmd_id); + if (it != commands_.end()) { + return it->second; + } + + return NULL; +} + +// TODO(VS): Create common functions for processing collections +void DynamicApplicationDataImpl::AddSubMenu( + uint32_t menu_id, const smart_objects::SmartObject& menu) { + sub_menu_[menu_id] = new smart_objects::SmartObject(menu); +} + +void DynamicApplicationDataImpl::RemoveSubMenu(uint32_t menu_id) { + SubMenuMap::iterator it = sub_menu_.find(menu_id); + + if (sub_menu_.end() != it) { + delete it->second; + sub_menu_.erase(menu_id); + } +} + +smart_objects::SmartObject* DynamicApplicationDataImpl::FindSubMenu( + uint32_t menu_id) const { + SubMenuMap::const_iterator it = sub_menu_.find(menu_id); + if (it != sub_menu_.end()) { + return it->second; + } + + return NULL; +} + +bool DynamicApplicationDataImpl::IsSubMenuNameAlreadyExist( + const std::string& name) { + for (SubMenuMap::iterator it = sub_menu_.begin(); + sub_menu_.end() != it; + ++it) { + smart_objects::SmartObject* menu = it->second; + if ((*menu)[strings::menu_name] == name) { + return true; + } + } + return false; +} + +void DynamicApplicationDataImpl::AddChoiceSet( + uint32_t choice_set_id, const smart_objects::SmartObject& choice_set) { + choice_set_map_[choice_set_id] = new smart_objects::SmartObject(choice_set); +} + +void DynamicApplicationDataImpl::RemoveChoiceSet(uint32_t choice_set_id) { + ChoiceSetMap::iterator it = choice_set_map_.find(choice_set_id); + + if (choice_set_map_.end() != it) { + delete it->second; + choice_set_map_.erase(choice_set_id); + } +} + +smart_objects::SmartObject* DynamicApplicationDataImpl::FindChoiceSet( + uint32_t choice_set_id) { + ChoiceSetMap::const_iterator it = choice_set_map_.find(choice_set_id); + if (it != choice_set_map_.end()) { + return it->second; + } + + return NULL; +} + +void DynamicApplicationDataImpl::AddPerformInteractionChoiceSet( + uint32_t choice_set_id, const smart_objects::SmartObject& vr_commands) { + performinteraction_choice_set_map_[choice_set_id] = + new smart_objects::SmartObject(vr_commands); +} + +void DynamicApplicationDataImpl::DeletePerformInteractionChoiceSetMap() { + PerformChoiceSetMap::iterator it = performinteraction_choice_set_map_.begin(); + for (; performinteraction_choice_set_map_.end() != it; ++it) { + delete it->second; + } + performinteraction_choice_set_map_.clear(); +} + +smart_objects::SmartObject* +DynamicApplicationDataImpl::FindPerformInteractionChoiceSet( + uint32_t choice_set_id) const { + PerformChoiceSetMap::const_iterator it = performinteraction_choice_set_map_ + .find(choice_set_id); + + if (it != performinteraction_choice_set_map_.end()) { + return it->second; + } + + return NULL; +} + +void DynamicApplicationDataImpl::set_perform_interaction_active( + uint32_t active) { + is_perform_interaction_active_ = active; +} + +void DynamicApplicationDataImpl::set_perform_interaction_ui_corrid( + uint32_t corr_id) { + perform_interaction_ui_corrid_ = corr_id; +} + +void DynamicApplicationDataImpl::set_reset_global_properties_active( + bool active) { + is_reset_global_properties_active_ = active; +} + +void DynamicApplicationDataImpl::set_perform_interaction_mode(int32_t mode) { + perform_interaction_mode_ = mode; +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc new file mode 100644 index 0000000000..2812c17ffb --- /dev/null +++ b/src/components/application_manager/src/application_impl.cc @@ -0,0 +1,740 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 <string> +#include <strings.h> +#include <stdlib.h> +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "config_profile/profile.h" +#include "interfaces/MOBILE_API.h" +#include "utils/file_system.h" +#include "utils/logger.h" + +namespace { + +mobile_apis::FileType::eType StringToFileType(const char* str) { + if (0 == strcasecmp(str, "json")) { + return mobile_apis::FileType::JSON; + } else if (0 == strcasecmp(str, "bmp")) { + return mobile_apis::FileType::GRAPHIC_BMP; + } else if (0 == strcasecmp(str, "jpeg")) { + return mobile_apis::FileType::GRAPHIC_JPEG; + } else if (0 == strcasecmp(str, "png")) { + return mobile_apis::FileType::GRAPHIC_PNG; + } else if (0 == strcasecmp(str, "wave")) { + return mobile_apis::FileType::AUDIO_WAVE; + } else if ((0 == strcasecmp(str, "m4a")) || + (0 == strcasecmp(str, "m4b")) || + (0 == strcasecmp(str, "m4p")) || + (0 == strcasecmp(str, "m4v")) || + (0 == strcasecmp(str, "m4r")) || + (0 == strcasecmp(str, "3gp")) || + (0 == strcasecmp(str, "mp4")) || + (0 == strcasecmp(str, "aac"))) { + return mobile_apis::FileType::AUDIO_AAC; + } else if (0 == strcasecmp(str, "mp3")) { + return mobile_apis::FileType::AUDIO_MP3; + } else { + return mobile_apis::FileType::BINARY; + } +} +} + +namespace application_manager { + +CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager") + +ApplicationImpl::ApplicationImpl(uint32_t application_id, + const std::string& mobile_app_id, + const std::string& app_name, + utils::SharedPtr<usage_statistics::StatisticsManager> statistics_manager) + : grammar_id_(0), + app_id_(application_id), + active_message_(NULL), + is_media_(false), + allowed_support_navigation_(false), + hmi_supports_navi_video_streaming_(false), + hmi_supports_navi_audio_streaming_(false), + is_app_allowed_(true), + has_been_activated_(false), + tts_speak_state_(false), + tts_properties_in_none_(false), + tts_properties_in_full_(false), + hmi_level_(mobile_api::HMILevel::HMI_NONE), + put_file_in_none_count_(0), + delete_file_in_none_count_(0), + list_files_in_none_count_(0), + system_context_(mobile_api::SystemContext::SYSCTXT_MAIN), + audio_streaming_state_(mobile_api::AudioStreamingState::NOT_AUDIBLE), + device_(0), + usage_report_(mobile_app_id, statistics_manager), + protocol_version_(ProtocolVersion::kV3), + is_video_stream_retry_active_(false), + is_audio_stream_retry_active_(false), + video_stream_retry_number_(0), + audio_stream_retry_number_(0) { + + cmd_number_to_time_limits_[mobile_apis::FunctionID::ReadDIDID] = + {date_time::DateTime::getCurrentTime(), 0}; + cmd_number_to_time_limits_[mobile_apis::FunctionID::GetVehicleDataID] = + {date_time::DateTime::getCurrentTime(), 0}; + + + set_mobile_app_id(smart_objects::SmartObject(mobile_app_id)); + set_name(app_name); + + // subscribe application to custom button by default + SubscribeToButton(mobile_apis::ButtonName::CUSTOM_BUTTON); + + // load persistent files + LoadPersistentFiles(); +} + +ApplicationImpl::~ApplicationImpl() { + // TODO(AK): check if this is correct assimption + if (active_message_) { + delete active_message_; + active_message_ = NULL; + } + + subscribed_buttons_.clear(); + subscribed_vehicle_info_.clear(); + if (is_perform_interaction_active()) { + set_perform_interaction_active(0); + set_perform_interaction_mode(-1); + DeletePerformInteractionChoiceSetMap(); + } + CleanupFiles(); +} + +void ApplicationImpl::CloseActiveMessage() { + delete active_message_; + active_message_ = NULL; +} + +bool ApplicationImpl::IsFullscreen() const { + return mobile_api::HMILevel::HMI_FULL == hmi_level_; +} + +bool ApplicationImpl::MakeFullscreen() { + hmi_level_ = mobile_api::HMILevel::HMI_FULL; + if (is_media_ && !tts_speak_state_) { + audio_streaming_state_ = mobile_api::AudioStreamingState::AUDIBLE; + } + system_context_ = mobile_api::SystemContext::SYSCTXT_MAIN; + if (!has_been_activated_) { + has_been_activated_ = true; + } + return true; +} + +bool ApplicationImpl::IsAudible() const { + return mobile_api::HMILevel::HMI_FULL == hmi_level_ + || mobile_api::HMILevel::HMI_LIMITED == hmi_level_; +} + +void ApplicationImpl::MakeNotAudible() { + hmi_level_ = mobile_api::HMILevel::HMI_BACKGROUND; + audio_streaming_state_ = mobile_api::AudioStreamingState::NOT_AUDIBLE; +} + +bool ApplicationImpl::allowed_support_navigation() const { + return allowed_support_navigation_; +} + +void ApplicationImpl::set_allowed_support_navigation(bool allow) { + allowed_support_navigation_ = allow; +} + +const smart_objects::SmartObject* ApplicationImpl::active_message() const { + return active_message_; +} + +const Version& ApplicationImpl::version() const { + return version_; +} + +void ApplicationImpl::set_hmi_application_id(uint32_t hmi_app_id) { + hmi_app_id_ = hmi_app_id; +} + +const std::string& ApplicationImpl::name() const { + return app_name_; +} + +const std::string ApplicationImpl::folder_name() const { + return name() + mobile_app_id()->asString(); +} + +bool ApplicationImpl::is_media_application() const { + return is_media_; +} + +const mobile_api::HMILevel::eType& ApplicationImpl::hmi_level() const { + return hmi_level_; +} + +const uint32_t ApplicationImpl::put_file_in_none_count() const { + return put_file_in_none_count_; +} + +const uint32_t ApplicationImpl::delete_file_in_none_count() const { + return delete_file_in_none_count_; +} + +const uint32_t ApplicationImpl::list_files_in_none_count() const { + return list_files_in_none_count_; +} + +const mobile_api::SystemContext::eType& +ApplicationImpl::system_context() const { + return system_context_; +} + +const std::string& ApplicationImpl::app_icon_path() const { + return app_icon_path_; +} + +connection_handler::DeviceHandle ApplicationImpl::device() const { + return device_; +} + +void ApplicationImpl::set_version(const Version& ver) { + version_ = ver; +} + +void ApplicationImpl::set_name(const std::string& name) { + app_name_ = name; +} + +void ApplicationImpl::set_is_media_application(bool is_media) { + is_media_ = is_media; + // Audio streaming state for non-media application can not be different + // from NOT_AUDIBLE + if (!is_media) + set_audio_streaming_state(mobile_api::AudioStreamingState::NOT_AUDIBLE); +} + +void ApplicationImpl::set_tts_speak_state(bool state_tts_speak) { + tts_speak_state_ = state_tts_speak; +} + +bool ApplicationImpl::tts_speak_state() { + return tts_speak_state_; +} + +void ApplicationImpl::set_tts_properties_in_none( + bool active) { + tts_properties_in_none_ = active; +} + +bool ApplicationImpl::tts_properties_in_none() { + return tts_properties_in_none_; +} + +void ApplicationImpl::set_tts_properties_in_full( + bool active) { + tts_properties_in_full_ = active; +} + +bool ApplicationImpl::tts_properties_in_full() { + return tts_properties_in_full_; +} + +void ApplicationImpl::set_hmi_level( + const mobile_api::HMILevel::eType& hmi_level) { + if (mobile_api::HMILevel::HMI_NONE != hmi_level_ && + mobile_api::HMILevel::HMI_NONE == hmi_level) { + put_file_in_none_count_ = 0; + delete_file_in_none_count_ = 0; + list_files_in_none_count_ = 0; + } + + hmi_level_ = hmi_level; + usage_report_.RecordHmiStateChanged(hmi_level); +} + +void ApplicationImpl::set_hmi_supports_navi_video_streaming(bool supports) { + hmi_supports_navi_video_streaming_ = supports; + + if ((!supports) && (!video_stream_retry_active())) { + std::pair<uint32_t, int32_t> stream_retry = + profile::Profile::instance()->start_stream_retry_amount(); + set_video_stream_retry_active(true); + video_stream_retry_number_ = stream_retry.first; + video_stream_retry_timer_ = + utils::SharedPtr<timer::TimerThread<ApplicationImpl>>( + new timer::TimerThread<ApplicationImpl>( + "VideoStreamRetry", this, &ApplicationImpl::OnVideoStreamRetry, true)); + // start separate pthread for timer without delays + video_stream_retry_timer_->start(0); + } +} + +bool ApplicationImpl::hmi_supports_navi_video_streaming() const { + return hmi_supports_navi_video_streaming_; +} + +void ApplicationImpl::set_hmi_supports_navi_audio_streaming(bool supports) { + hmi_supports_navi_audio_streaming_ = supports; + + if ((!supports) && (!audio_stream_retry_active())) { + std::pair<uint32_t, int32_t> stream_retry = + profile::Profile::instance()->start_stream_retry_amount(); + set_audio_stream_retry_active(true); + audio_stream_retry_number_ = stream_retry.first; + audio_stream_retry_timer_ = + utils::SharedPtr<timer::TimerThread<ApplicationImpl>>( + new timer::TimerThread<ApplicationImpl>( + "AudioStreamRetry", this, &ApplicationImpl::OnAudioStreamRetry, true)); + // start separate pthread for timer without delays + audio_stream_retry_timer_->start(0); + } +} + +bool ApplicationImpl::hmi_supports_navi_audio_streaming() const { + return hmi_supports_navi_audio_streaming_; +} + +bool ApplicationImpl::video_stream_retry_active() const { + return is_video_stream_retry_active_; +} + +void ApplicationImpl::set_video_stream_retry_active(bool active) { + is_video_stream_retry_active_ = active; +} + +bool ApplicationImpl::audio_stream_retry_active() const { + return is_audio_stream_retry_active_; +} + +void ApplicationImpl::set_audio_stream_retry_active(bool active) { + is_audio_stream_retry_active_ = active; +} + +void ApplicationImpl::OnVideoStreamRetry() { + if (video_stream_retry_number_) { + LOG4CXX_INFO(logger_, "Send video stream retry " + << video_stream_retry_number_); + + application_manager::MessageHelper::SendNaviStartStream(app_id()); + --video_stream_retry_number_; + + std::pair<uint32_t, int32_t> stream_retry = + profile::Profile::instance()->start_stream_retry_amount(); + int32_t time_out = stream_retry.second; + video_stream_retry_timer_->updateTimeOut(time_out); + } else { + LOG4CXX_INFO(logger_, "Stop video streaming retry"); + video_stream_retry_timer_.release(); + set_video_stream_retry_active(false); + } +} + +void ApplicationImpl::OnAudioStreamRetry() { + if (audio_stream_retry_number_) { + LOG4CXX_INFO(logger_, "Send audio streaming retry " + << audio_stream_retry_number_); + + application_manager::MessageHelper::SendAudioStartStream(app_id()); + --audio_stream_retry_number_; + + std::pair<uint32_t, int32_t> stream_retry = + profile::Profile::instance()->start_stream_retry_amount(); + int32_t time_out = stream_retry.second; + audio_stream_retry_timer_->updateTimeOut(time_out); + } else { + LOG4CXX_INFO(logger_, "Stop audio streaming retry"); + audio_stream_retry_timer_.release(); + set_audio_stream_retry_active(false); + } +} + +void ApplicationImpl::increment_put_file_in_none_count() { + ++put_file_in_none_count_; +} + +void ApplicationImpl::increment_delete_file_in_none_count() { + ++delete_file_in_none_count_; +} + +void ApplicationImpl::increment_list_files_in_none_count() { + ++list_files_in_none_count_; +} + +void ApplicationImpl::set_system_context( + const mobile_api::SystemContext::eType& system_context) { + system_context_ = system_context; +} + +void ApplicationImpl::set_audio_streaming_state( + const mobile_api::AudioStreamingState::eType& state) { + if (!is_media_application() + && state != mobile_api::AudioStreamingState::NOT_AUDIBLE) { + LOG4CXX_WARN(logger_, "Trying to set audio streaming state" + " for non-media application to different from NOT_AUDIBLE"); + return; + } + audio_streaming_state_ = state; +} + +bool ApplicationImpl::set_app_icon_path(const std::string& path) { + if (app_files_.find(path) != app_files_.end()) { + app_icon_path_ = path; + return true; + } + return false; +} + +void ApplicationImpl::set_app_allowed(const bool& allowed) { + is_app_allowed_ = allowed; +} + +void ApplicationImpl::set_device(connection_handler::DeviceHandle device) { + device_ = device; +} + +uint32_t ApplicationImpl::get_grammar_id() const { + return grammar_id_; +} + +void ApplicationImpl::set_grammar_id(uint32_t value) { + grammar_id_ = value; +} + +bool ApplicationImpl::has_been_activated() const { + return has_been_activated_; +} + +void ApplicationImpl::set_protocol_version( + const ProtocolVersion& protocol_version) { + protocol_version_ = protocol_version; +} + +ProtocolVersion ApplicationImpl::protocol_version() const { + return protocol_version_; +} + +bool ApplicationImpl::AddFile(AppFile& file) { + if (app_files_.count(file.file_name) == 0) { + LOG4CXX_INFO(logger_, "AddFile file " << file.file_name + << " File type is " << file.file_type); + app_files_[file.file_name] = file; + return true; + } + return false; +} + +bool ApplicationImpl::UpdateFile(AppFile& file) { + if (app_files_.count(file.file_name) != 0) { + LOG4CXX_INFO(logger_, "UpdateFile file " << file.file_name + << " File type is " << file.file_type); + app_files_[file.file_name] = file; + return true; + } + return false; +} + +bool ApplicationImpl::DeleteFile(const std::string& file_name) { + AppFilesMap::iterator it = app_files_.find(file_name); + if (it != app_files_.end()) { + LOG4CXX_INFO(logger_, "DeleteFile file " << it->second.file_name + << " File type is " << it->second.file_type); + app_files_.erase(it); + return true; + } + return false; +} + +const AppFilesMap& ApplicationImpl::getAppFiles() const { + return this->app_files_; +} + +const AppFile* ApplicationImpl::GetFile(const std::string& file_name) { + if (app_files_.find(file_name) != app_files_.end()) { + return &(app_files_[file_name]); + } + return NULL; +} + +bool ApplicationImpl::SubscribeToButton(mobile_apis::ButtonName::eType btn_name) { + size_t old_size = subscribed_buttons_.size(); + subscribed_buttons_.insert(btn_name); + return (subscribed_buttons_.size() == old_size + 1); +} + +bool ApplicationImpl::IsSubscribedToButton(mobile_apis::ButtonName::eType btn_name) { + std::set<mobile_apis::ButtonName::eType>::iterator it = subscribed_buttons_.find(btn_name); + return (subscribed_buttons_.end() != it); +} + +bool ApplicationImpl::UnsubscribeFromButton(mobile_apis::ButtonName::eType btn_name) { + size_t old_size = subscribed_buttons_.size(); + subscribed_buttons_.erase(btn_name); + return (subscribed_buttons_.size() == old_size - 1); +} + +bool ApplicationImpl::SubscribeToIVI(uint32_t vehicle_info_type_) { + size_t old_size = subscribed_vehicle_info_.size(); + subscribed_vehicle_info_.insert(vehicle_info_type_); + return (subscribed_vehicle_info_.size() == old_size + 1); +} + +bool ApplicationImpl::IsSubscribedToIVI(uint32_t vehicle_info_type_) { + std::set<uint32_t>::iterator it = subscribed_vehicle_info_.find( + vehicle_info_type_); + return (subscribed_vehicle_info_.end() != it); +} + +bool ApplicationImpl::UnsubscribeFromIVI(uint32_t vehicle_info_type_) { + size_t old_size = subscribed_vehicle_info_.size(); + subscribed_vehicle_info_.erase(vehicle_info_type_); + return (subscribed_vehicle_info_.size() == old_size - 1); +} + +UsageStatistics& ApplicationImpl::usage_report() { + return usage_report_; +} + +bool ApplicationImpl::IsCommandLimitsExceeded( + mobile_apis::FunctionID::eType cmd_id, + TLimitSource source) { + TimevalStruct current = date_time::DateTime::getCurrentTime(); + switch (source) { + // In case of config file values there is COMMON limitations for number of + // commands per certain time in seconds, i.e. 5 requests per 10 seconds with + // any interval between them + case CONFIG_FILE: { + CommandNumberTimeLimit::iterator it = + cmd_number_to_time_limits_.find(cmd_id); + if (cmd_number_to_time_limits_.end() == it) { + LOG4CXX_WARN(logger_, "Limits for command id " << cmd_id + << "had not been set."); + return true; + } + + TimeToNumberLimit& limit = it->second; + + std::pair<uint32_t, int32_t> frequency_restrictions; + + if (mobile_apis::FunctionID::ReadDIDID == cmd_id) { + frequency_restrictions = + profile::Profile::instance()->read_did_frequency(); + + } else if (mobile_apis::FunctionID::GetVehicleDataID == cmd_id) { + frequency_restrictions = + profile::Profile::instance()->get_vehicle_data_frequency(); + } else { + LOG4CXX_INFO(logger_, "No restrictions for request"); + return false; + } + + LOG4CXX_INFO(logger_, "Time Info: " << + "\n Current: " << current.tv_sec << + "\n Limit: (" << limit.first.tv_sec << "," << limit.second << ")" + "\n frequency_restrictions: (" << frequency_restrictions.first << "," << frequency_restrictions.second << ")" + ); + if (current.tv_sec < limit.first.tv_sec + frequency_restrictions.second) { + if (limit.second < frequency_restrictions.first) { + ++limit.second; + return false; + } + return true; + } + + limit.first = current; + limit.second = 1; + + return false; + + break; + } + // In case of policy table values, there is EVEN limitation for number of + // commands per minute, e.g. 10 command per minute i.e. 1 command per 6 sec + case POLICY_TABLE: { + uint32_t cmd_limit = application_manager::MessageHelper::GetAppCommandLimit( + mobile_app_id_->asString()); + + if (0 == cmd_limit) { + return true; + } + + const uint32_t dummy_limit = 1; + CommandNumberTimeLimit::iterator it = + cmd_number_to_time_limits_.find(cmd_id); + // If no command with cmd_id had been executed yet, just add to limits + if (cmd_number_to_time_limits_.end() == it) { + cmd_number_to_time_limits_[cmd_id] = {current, dummy_limit}; + return false; + } + + const uint32_t minute = 60; + + TimeToNumberLimit& limit = it->second; + + // Checking even limitation for command + if (static_cast<uint32_t>(current.tv_sec - limit.first.tv_sec) < + minute/cmd_limit) { + return true; + } + + cmd_number_to_time_limits_[cmd_id] = {current, dummy_limit}; + + return false; + break; + } + default: { + LOG4CXX_WARN(logger_, "Limit source is not implemented."); + break; + } + } + + return true; +} + +const std::set<mobile_apis::ButtonName::eType>& ApplicationImpl::SubscribedButtons() const { + return subscribed_buttons_; +} + +const std::set<uint32_t>& ApplicationImpl::SubscribesIVI() const { + return subscribed_vehicle_info_; +} + +uint32_t ApplicationImpl::nextHash() { + hash_val_ = rand(); + return hash_val_; +} + +uint32_t ApplicationImpl::curHash() const { + return hash_val_; +} + +uint32_t ApplicationImpl::UpdateHash() { + uint32_t new_hash= nextHash(); + MessageHelper::SendHashUpdateNotification(app_id()); + return new_hash; +} + +void ApplicationImpl::CleanupFiles() { + std::string directory_name = + profile::Profile::instance()->app_storage_folder(); + directory_name += "/" + folder_name(); + + if (file_system::DirectoryExists(directory_name)) { + std::vector<std::string> files = file_system::ListFiles( + directory_name); + AppFilesMap::const_iterator app_files_it; + + std::vector<std::string>::const_iterator it = files.begin(); + for (; it != files.end(); ++it) { + std::string file_name = directory_name; + file_name += "/"; + file_name += *it; + app_files_it = app_files_.find(file_name); + if ((app_files_it == app_files_.end()) || + (!app_files_it->second.is_persistent)) { + LOG4CXX_INFO(logger_, "DeleteFile file " << file_name); + file_system::DeleteFile(file_name); + } + } + + file_system::RemoveDirectory(directory_name, false); + } + app_files_.clear(); +} + +void ApplicationImpl::LoadPersistentFiles() { + std::string directory_name = + profile::Profile::instance()->app_storage_folder(); + directory_name += "/" + folder_name(); + + if (file_system::DirectoryExists(directory_name)) { + std::vector<std::string> persistent_files = + file_system::ListFiles(directory_name); + + std::vector<std::string>::const_iterator it = persistent_files.begin(); + for (; it != persistent_files.end(); ++it) { + AppFile file; + file.is_persistent = true; + file.is_download_complete = true; + file.file_name = directory_name; + file.file_name += "/"; + file.file_name += *it; + file.file_type = mobile_apis::FileType::BINARY; + // Search file extension and convert it to the type + std::size_t index = it->find_last_of('.'); + if (index != std::string::npos) { + std::string file_type = it->substr(++index); + file.file_type = StringToFileType(file_type.c_str()); + } + + LOG4CXX_INFO(logger_, "Loaded persistent file " << file.file_name + << " File type is " << file.file_type); + AddFile(file); + } + } +} + +void ApplicationImpl::SubscribeToSoftButtons(int32_t cmd_id, + const SoftButtonID& softbuttons_id) { + sync_primitives::AutoLock lock(cmd_softbuttonid_lock_); + if (static_cast<int32_t>(mobile_apis::FunctionID::ScrollableMessageID) == cmd_id) { + CommandSoftButtonID::iterator it = cmd_softbuttonid_.find(cmd_id); + if (cmd_softbuttonid_.end() == it) { + cmd_softbuttonid_[cmd_id] = softbuttons_id; + } + } else { + cmd_softbuttonid_[cmd_id] = softbuttons_id; + } +} + +bool ApplicationImpl::IsSubscribedToSoftButton(const uint32_t softbutton_id) { + sync_primitives::AutoLock lock(cmd_softbuttonid_lock_); + CommandSoftButtonID::iterator it = cmd_softbuttonid_.begin(); + for (; it != cmd_softbuttonid_.end(); ++it) { + if((it->second).find(softbutton_id) != (it->second).end()) { + return true; + } + } + return false; +} + +void ApplicationImpl::UnsubscribeFromSoftButtons(int32_t cmd_id) { + sync_primitives::AutoLock lock(cmd_softbuttonid_lock_); + CommandSoftButtonID::iterator it = cmd_softbuttonid_.find(cmd_id); + if(it != cmd_softbuttonid_.end()) { + cmd_softbuttonid_.erase(it); + } +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc new file mode 100644 index 0000000000..d6beb3c497 --- /dev/null +++ b/src/components/application_manager/src/application_manager_impl.cc @@ -0,0 +1,2338 @@ +/* + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 <stdlib.h> // for rand() + +#include <climits> +#include <string> +#include <fstream> + +#include "application_manager/application_manager_impl.h" +#include "application_manager/mobile_command_factory.h" +#include "application_manager/commands/command_impl.h" +#include "application_manager/commands/command_notification_impl.h" +#include "application_manager/message_helper.h" +#include "application_manager/mobile_message_handler.h" +#include "application_manager/policies/policy_handler.h" +#include "hmi_message_handler/hmi_message_handler.h" +#include "connection_handler/connection_handler_impl.h" +#include "formatters/formatter_json_rpc.h" +#include "formatters/CFormatterJsonSDLRPCv2.hpp" +#include "formatters/CFormatterJsonSDLRPCv1.hpp" +#include "config_profile/profile.h" +#include "utils/threads/thread.h" +#include "utils/file_system.h" +#include "application_manager/application_impl.h" +#include "usage_statistics/counter.h" +#include <time.h> + +namespace application_manager { + +CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager") + +uint32_t ApplicationManagerImpl::corelation_id_ = 0; +const uint32_t ApplicationManagerImpl::max_corelation_id_ = UINT_MAX; + +namespace formatters = NsSmartDeviceLink::NsJSONHandler::Formatters; +namespace jhs = NsSmartDeviceLink::NsJSONHandler::strings; + +ApplicationManagerImpl::ApplicationManagerImpl() + : applications_list_lock_(true), + audio_pass_thru_active_(false), + is_distracting_driver_(false), + is_vr_session_strated_(false), + hmi_cooperating_(false), + is_all_apps_allowed_(true), + media_manager_(NULL), + hmi_handler_(NULL), + connection_handler_(NULL), + protocol_handler_(NULL), + request_ctrl_(), + hmi_so_factory_(NULL), + mobile_so_factory_(NULL), + messages_from_mobile_("AM FromMobile", this), + messages_to_mobile_("AM ToMobile", this), + messages_from_hmi_("AM FromHMI", this), + messages_to_hmi_("AM ToHMI", this), + hmi_capabilities_(this), + unregister_reason_(mobile_api::AppInterfaceUnregisteredReason::IGNITION_OFF), + resume_ctrl_(this), +#ifdef TIME_TESTER + metric_observer_(NULL), +#endif // TIME_TESTER + application_list_update_timer_(new ApplicationListUpdateTimer(this)), + tts_global_properties_timer_("TTSGLPRTimer", + this, + &ApplicationManagerImpl::OnTimerSendTTSGlobalProperties, + true) { + std::srand(std::time(0)); +} + +ApplicationManagerImpl::~ApplicationManagerImpl() { + LOG4CXX_INFO(logger_, "Destructing ApplicationManager."); + + SendOnSDLClose(); + media_manager_ = NULL; + hmi_handler_ = NULL; + connection_handler_ = NULL; + if (hmi_so_factory_) { + delete hmi_so_factory_; + } + hmi_so_factory_ = NULL; + if (mobile_so_factory_) { + delete mobile_so_factory_; + } + mobile_so_factory_ = NULL; + protocol_handler_ = NULL; + media_manager_ = NULL; + LOG4CXX_INFO(logger_, "Destroying Policy Handler"); + policy::PolicyHandler::destroy(); +} + +bool ApplicationManagerImpl::Stop() { + LOG4CXX_INFO(logger_, "Stop ApplicationManager."); + application_list_update_timer_->stop(); + try { + UnregisterAllApplications(); + } catch (...) { + LOG4CXX_ERROR(logger_, + "An error occurred during unregistering applications."); + } + + + // for PASA customer policy backup should happen OnExitAllApp(SUSPEND) + LOG4CXX_INFO(logger_, "Unloading policy library."); + policy::PolicyHandler::instance()->UnloadPolicyLibrary(); + + return true; +} + +ApplicationSharedPtr ApplicationManagerImpl::application(uint32_t app_id) const { + sync_primitives::AutoLock lock(applications_list_lock_); + + std::set<ApplicationSharedPtr>::const_iterator it = + application_list_.begin(); + for (; it != application_list_.end(); ++it) { + if ((*it)->app_id() == app_id) { + return (*it); + } + } + return ApplicationSharedPtr(); +} + +ApplicationSharedPtr ApplicationManagerImpl::application_by_hmi_app( + uint32_t hmi_app_id) const { + sync_primitives::AutoLock lock(applications_list_lock_); + + std::set<ApplicationSharedPtr>::const_iterator it = + application_list_.begin(); + for (; it != application_list_.end(); ++it) { + if ((*it)->hmi_app_id() == hmi_app_id) { + return (*it); + } + } + return ApplicationSharedPtr(); +} + +ApplicationSharedPtr ApplicationManagerImpl::application_by_policy_id( + const std::string& policy_app_id) const { + sync_primitives::AutoLock lock(applications_list_lock_); + + std::vector<ApplicationSharedPtr> result; + for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + application_list_.end() != it; + ++it) { + if (policy_app_id.compare((*it)->mobile_app_id()->asString()) == 0) { + return *it; + } + } + return ApplicationSharedPtr(); +} + +ApplicationSharedPtr ApplicationManagerImpl::active_application() const { + // TODO(DK) : check driver distraction + for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + application_list_.end() != it; + ++it) { + if ((*it)->IsFullscreen()) { + return *it; + } + } + return ApplicationSharedPtr(); +} + +std::vector<ApplicationSharedPtr> ApplicationManagerImpl::applications_by_button( + uint32_t button) { + std::vector<ApplicationSharedPtr> result; + for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + application_list_.end() != it; ++it) { + if ((*it)->IsSubscribedToButton( + static_cast<mobile_apis::ButtonName::eType>(button))) { + result.push_back(*it); + } + } + return result; +} + +std::vector<utils::SharedPtr<Application>> ApplicationManagerImpl::IviInfoUpdated( +VehicleDataType vehicle_info, int value) { + // Notify Policy Manager if available about info it's interested in, + // i.e. odometer etc + switch (vehicle_info) { + case ODOMETER: + policy::PolicyHandler::instance()->KmsChanged(value); + break; + default: + break; + } + + std::vector<utils::SharedPtr<application_manager::Application>> result; + for (std::set<utils::SharedPtr<application_manager::Application>>::iterator it = application_list_.begin(); + application_list_.end() != it; ++it) { + if ((*it)->IsSubscribedToIVI(static_cast<uint32_t>(vehicle_info))) { + result.push_back(*it); + } + } + return result; +} + +std::vector<ApplicationSharedPtr> ApplicationManagerImpl::applications_with_navi() { + std::vector<ApplicationSharedPtr> result; + for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + application_list_.end() != it; + ++it) { + if ((*it)->allowed_support_navigation()) { + result.push_back(*it); + } + } + return result; +} + +ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication( + const utils::SharedPtr<smart_objects::SmartObject>& + request_for_registration) { + + LOG4CXX_DEBUG(logger_, "Restarting application list update timer"); + uint32_t timeout = profile::Profile::instance()->application_list_update_timeout(); + application_list_update_timer_->start(timeout); + + smart_objects::SmartObject& message = *request_for_registration; + uint32_t connection_key = + message[strings::params][strings::connection_key].asInt(); + + if (false == is_all_apps_allowed_) { + LOG4CXX_INFO(logger_, + "RegisterApplication: access to app's disabled by user"); + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + connection_key, mobile_apis::FunctionID::RegisterAppInterfaceID, + message[strings::params][strings::correlation_id].asUInt(), + mobile_apis::Result::DISALLOWED)); + ManageMobileCommand(response); + return ApplicationSharedPtr(); + } + + // app_id is SDL "internal" ID + // original app_id can be gotten via ApplicationImpl::mobile_app_id() + uint32_t app_id = 0; + std::list<int32_t> sessions_list; + uint32_t device_id = 0; + + if (connection_handler_) { + connection_handler::ConnectionHandlerImpl* con_handler_impl = + static_cast<connection_handler::ConnectionHandlerImpl*>( + + connection_handler_); + if (con_handler_impl->GetDataOnSessionKey(connection_key, &app_id, + &sessions_list, &device_id) + == -1) { + LOG4CXX_ERROR(logger_, + "Failed to create application: no connection info."); + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + connection_key, mobile_apis::FunctionID::RegisterAppInterfaceID, + message[strings::params][strings::correlation_id].asUInt(), + mobile_apis::Result::GENERIC_ERROR)); + ManageMobileCommand(response); + return ApplicationSharedPtr(); + } + } + + smart_objects::SmartObject& params = message[strings::msg_params]; + + const std::string& mobile_app_id = params[strings::app_id].asString(); + const std::string& app_name = + message[strings::msg_params][strings::app_name].asString(); + + ApplicationSharedPtr application( + new ApplicationImpl(app_id, + mobile_app_id, app_name, + policy::PolicyHandler::instance()->GetStatisticManager())); + if (!application) { + usage_statistics::AppCounter count_of_rejections_sync_out_of_memory( + policy::PolicyHandler::instance()->GetStatisticManager(), mobile_app_id, + usage_statistics::REJECTIONS_SYNC_OUT_OF_MEMORY); + ++count_of_rejections_sync_out_of_memory; + + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + connection_key, mobile_apis::FunctionID::RegisterAppInterfaceID, + message[strings::params][strings::correlation_id].asUInt(), + mobile_apis::Result::OUT_OF_MEMORY)); + ManageMobileCommand(response); + return ApplicationSharedPtr(); + } + application->set_device(device_id); + application->set_grammar_id(GenerateGrammarID()); + mobile_api::Language::eType launguage_desired = + static_cast<mobile_api::Language::eType>(params[strings::language_desired] + .asInt()); + application->set_language(launguage_desired); + application->usage_report().RecordAppRegistrationVuiLanguage( + launguage_desired); + + mobile_api::Language::eType hmi_display_language_desired = + static_cast<mobile_api::Language::eType>(params[strings::hmi_display_language_desired] + .asInt()); + application->set_ui_language(hmi_display_language_desired); + application->usage_report().RecordAppRegistrationGuiLanguage( + hmi_display_language_desired); + + Version version; + int32_t min_version = + message[strings::msg_params][strings::sync_msg_version] + [strings::minor_version].asInt(); + + /*if (min_version < APIVersion::kAPIV2) { + LOG4CXX_ERROR(logger_, "UNSUPPORTED_VERSION"); + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + connection_key, mobile_apis::FunctionID::RegisterAppInterfaceID, + message[strings::params][strings::correlation_id], + mobile_apis::Result::UNSUPPORTED_VERSION)); + ManageMobileCommand(response); + delete application; + return NULL; + }*/ + version.min_supported_api_version = static_cast<APIVersion>(min_version); + + int32_t max_version = + message[strings::msg_params][strings::sync_msg_version] + [strings::major_version].asInt(); + + /*if (max_version > APIVersion::kAPIV2) { + LOG4CXX_ERROR(logger_, "UNSUPPORTED_VERSION"); + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + connection_key, mobile_apis::FunctionID::RegisterAppInterfaceID, + message[strings::params][strings::correlation_id], + mobile_apis::Result::UNSUPPORTED_VERSION)); + ManageMobileCommand(response); + delete application; + return NULL; + }*/ + version.max_supported_api_version = static_cast<APIVersion>(max_version); + application->set_version(version); + + ProtocolVersion protocol_version = static_cast<ProtocolVersion>( + message[strings::params][strings::protocol_version].asInt()); + application->set_protocol_version(protocol_version); + + if (connection_handler_) { + if (ProtocolVersion::kUnknownProtocol != protocol_version) { + connection_handler_->BindProtocolVersionWithSession( + connection_key, static_cast<uint8_t>(protocol_version)); + } + if (ProtocolVersion::kV3 == protocol_version) { + connection_handler_->StartSessionHeartBeat(connection_key); + } + } + + sync_primitives::AutoLock lock(applications_list_lock_); + + application_list_.insert(application); + + return application; +} + +bool ApplicationManagerImpl::RemoveAppDataFromHMI(ApplicationSharedPtr app) { + return true; +} + +bool ApplicationManagerImpl::LoadAppDataToHMI(ApplicationSharedPtr app) { + return true; +} + +bool ApplicationManagerImpl::ActivateApplication(ApplicationSharedPtr app) { + if (!app) { + LOG4CXX_ERROR(logger_, "Null-pointer application received."); + NOTREACHED(); + return false; + } + + bool is_new_app_media = app->is_media_application(); + + if (app->IsFullscreen()) { + LOG4CXX_WARN(logger_, "Application is already active."); + return false; + } + if (mobile_api::HMILevel::eType::HMI_LIMITED != + app->hmi_level()) { + if (app->has_been_activated()) { + MessageHelper::SendAppDataToHMI(app); + } + } + app->MakeFullscreen(); + for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + application_list_.end() != it; + ++it) { + ApplicationSharedPtr curr_app = *it; + if (app->app_id() == curr_app->app_id()) { + continue; + } else { + if (is_new_app_media) { + if (curr_app->IsAudible()) { + curr_app->MakeNotAudible(); + MessageHelper::SendHMIStatusNotification(*curr_app); + } + } + if (curr_app->IsFullscreen()) { + if (true == curr_app->is_media_application()) { + PutApplicationInLimited(app); + } else { + app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND); + } + MessageHelper::SendHMIStatusNotification(*curr_app); + } + } + } + return true; +} + +mobile_apis::HMILevel::eType ApplicationManagerImpl::PutApplicationInLimited( + ApplicationSharedPtr app) { + DCHECK(app.get()) + + mobile_api::HMILevel::eType result = mobile_api::HMILevel::HMI_LIMITED; + + for (std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + application_list_.end() != it; + ++it) { + ApplicationSharedPtr curr_app = *it; + if (app->app_id() == curr_app->app_id()) { + continue; + } + + if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_LIMITED) { + result = mobile_api::HMILevel::HMI_BACKGROUND; + break; + } + if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_FULL) { + if (curr_app->is_media_application()) { + result = mobile_api::HMILevel::HMI_BACKGROUND; + break; + } else { + result = mobile_api::HMILevel::HMI_LIMITED; + } + } + + } + app->set_hmi_level(result); + return result; +} + +mobile_api::HMILevel::eType ApplicationManagerImpl::PutApplicationInFull( + ApplicationSharedPtr app) { + DCHECK(app.get()) + + bool is_new_app_media = app->is_media_application(); + mobile_api::HMILevel::eType result = mobile_api::HMILevel::HMI_FULL; + + std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + for (; application_list_.end() != it; ++it) { + ApplicationSharedPtr curr_app = *it; + if (app->app_id() == curr_app->app_id()) { + continue; + } + + if (is_new_app_media) { + if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_FULL) { + if (curr_app->is_media_application()) { + result = mobile_api::HMILevel::HMI_BACKGROUND; + break; + } else { + result = mobile_api::HMILevel::HMI_LIMITED; + } + } + if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_LIMITED) { + result = mobile_api::HMILevel::HMI_BACKGROUND; + break; + } + } else { + if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_FULL) { + result = mobile_api::HMILevel::HMI_BACKGROUND; + break; + } + if (curr_app->hmi_level() == mobile_api::HMILevel::HMI_LIMITED) { + result = mobile_api::HMILevel::HMI_FULL; + } + } + } + + if (result == mobile_api::HMILevel::HMI_FULL) { + app->set_hmi_level(result); + MessageHelper::SendActivateAppToHMI(app->app_id()); + } + return result; +} + +void ApplicationManagerImpl::ConnectToDevice(uint32_t id) { + // TODO(VS): Call function from ConnectionHandler + if (!connection_handler_) { + LOG4CXX_WARN(logger_, "Connection handler is not set."); + return; + } + + connection_handler_->ConnectToDevice(id); +} + +void ApplicationManagerImpl::OnHMIStartedCooperation() { + hmi_cooperating_ = true; + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnHMIStartedCooperation()"); + + utils::SharedPtr<smart_objects::SmartObject> is_vr_ready( + MessageHelper::CreateModuleInfoSO( + static_cast<uint32_t>(hmi_apis::FunctionID::VR_IsReady))); + ManageHMICommand(is_vr_ready); + + utils::SharedPtr<smart_objects::SmartObject> is_tts_ready( + MessageHelper::CreateModuleInfoSO(hmi_apis::FunctionID::TTS_IsReady)); + ManageHMICommand(is_tts_ready); + + utils::SharedPtr<smart_objects::SmartObject> is_ui_ready( + MessageHelper::CreateModuleInfoSO(hmi_apis::FunctionID::UI_IsReady)); + ManageHMICommand(is_ui_ready); + + utils::SharedPtr<smart_objects::SmartObject> is_navi_ready( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::Navigation_IsReady)); + ManageHMICommand(is_navi_ready); + + utils::SharedPtr<smart_objects::SmartObject> is_ivi_ready( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::VehicleInfo_IsReady)); + ManageHMICommand(is_ivi_ready); + + utils::SharedPtr<smart_objects::SmartObject> button_capabilities( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::Buttons_GetCapabilities)); + ManageHMICommand(button_capabilities); + + utils::SharedPtr<smart_objects::SmartObject> mixing_audio_supported_request( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::BasicCommunication_MixingAudioSupported)); + ManageHMICommand(mixing_audio_supported_request); +} + +uint32_t ApplicationManagerImpl::GetNextHMICorrelationID() { + if (corelation_id_ < max_corelation_id_) { + corelation_id_++; + } else { + corelation_id_ = 0; + } + + return corelation_id_; +} + +bool ApplicationManagerImpl::begin_audio_pass_thru() { + sync_primitives::AutoLock lock(audio_pass_thru_lock_); + if (audio_pass_thru_active_) { + return false; + } else { + audio_pass_thru_active_ = true; + return true; + } +} + +bool ApplicationManagerImpl::end_audio_pass_thru() { + sync_primitives::AutoLock lock(audio_pass_thru_lock_); + if (audio_pass_thru_active_) { + audio_pass_thru_active_ = false; + return true; + } else { + return false; + } +} + +void ApplicationManagerImpl::set_driver_distraction(bool is_distracting) { + is_distracting_driver_ = is_distracting; +} + +void ApplicationManagerImpl::set_vr_session_started(const bool& state) { + is_vr_session_strated_ = state; +} + +void ApplicationManagerImpl::set_all_apps_allowed(const bool& allowed) { + is_all_apps_allowed_ = allowed; +} + +void ApplicationManagerImpl::StartAudioPassThruThread(int32_t session_key, + int32_t correlation_id, int32_t max_duration, int32_t sampling_rate, + int32_t bits_per_sample, int32_t audio_type) { + LOG4CXX_INFO(logger_, "START MICROPHONE RECORDER"); + if (NULL != media_manager_) { + media_manager_->StartMicrophoneRecording( + session_key, + profile::Profile::instance()->recording_file_name(), + max_duration); + } +} + +void ApplicationManagerImpl::SendAudioPassThroughNotification( + uint32_t session_key, + std::vector<uint8_t> binaryData) { + LOG4CXX_TRACE_ENTER(logger_); + + if (!audio_pass_thru_active_) { + LOG4CXX_ERROR(logger_, "Trying to send PassThroughNotification" + " when PassThrough is not active"); + return; + } + smart_objects::SmartObject* on_audio_pass = NULL; + on_audio_pass = new smart_objects::SmartObject(); + + if (NULL == on_audio_pass) { + LOG4CXX_ERROR_EXT(logger_, "OnAudioPassThru NULL pointer"); + + return; + } + + LOG4CXX_INFO_EXT(logger_, "Fill smart object"); + + (*on_audio_pass)[strings::params][strings::message_type] = + application_manager::MessageType::kNotification; + + (*on_audio_pass)[strings::params][strings::connection_key] = + static_cast<int32_t>(session_key); + (*on_audio_pass)[strings::params][strings::function_id] = + mobile_apis::FunctionID::OnAudioPassThruID; + + LOG4CXX_INFO_EXT(logger_, "Fill binary data"); + // binary data + (*on_audio_pass)[strings::params][strings::binary_data] = + smart_objects::SmartObject(binaryData); + + LOG4CXX_INFO_EXT(logger_, "After fill binary data"); + + LOG4CXX_INFO_EXT(logger_, "Send data"); + CommandSharedPtr command ( + MobileCommandFactory::CreateCommand(&(*on_audio_pass))); + command->Init(); + command->Run(); + command->CleanUp(); +} + +void ApplicationManagerImpl::StopAudioPassThru(int32_t application_key) { + LOG4CXX_TRACE_ENTER(logger_); + sync_primitives::AutoLock lock(audio_pass_thru_lock_); + if (NULL != media_manager_) { + media_manager_->StopMicrophoneRecording(application_key); + } +} + +std::string ApplicationManagerImpl::GetDeviceName( + connection_handler::DeviceHandle handle) { + DCHECK(connection_handler_ != 0); + + std::string device_name = ""; + connection_handler::ConnectionHandlerImpl* con_handler_impl = + static_cast<connection_handler::ConnectionHandlerImpl*>( + connection_handler_); + if (con_handler_impl->GetDataOnDeviceID(handle, &device_name, + NULL) == -1) { + LOG4CXX_ERROR(logger_, "Failed to extract device name for id " << handle); + } else { + LOG4CXX_INFO(logger_, "\t\t\t\t\tDevice name is " << device_name); + } + + return device_name; +} + +void ApplicationManagerImpl::OnMessageReceived( + const RawMessagePtr message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnMessageReceived"); + + if (!message) { + LOG4CXX_ERROR(logger_, "Null-pointer message received."); + NOTREACHED(); + return; + } + + utils::SharedPtr<Message> outgoing_message = ConvertRawMsgToMessage(message); + + if (outgoing_message) { + messages_from_mobile_.PostMessage( + impl::MessageFromMobile(outgoing_message)); + } +} + +void ApplicationManagerImpl::OnMobileMessageSent( + const RawMessagePtr message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnMobileMessageSent"); +} + +void ApplicationManagerImpl::OnMessageReceived( + hmi_message_handler::MessageSharedPointer message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnMessageReceived"); + + if (!message) { + LOG4CXX_ERROR(logger_, "Null-pointer message received."); + NOTREACHED(); + return; + } + + messages_from_hmi_.PostMessage(impl::MessageFromHmi(message)); +} + +void ApplicationManagerImpl::OnErrorSending( + hmi_message_handler::MessageSharedPointer message) { + return; +} + +void ApplicationManagerImpl::OnDeviceListUpdated( + const connection_handler::DeviceMap& device_list) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::OnDeviceListUpdated"); + + smart_objects::SmartObject* update_list = new smart_objects::SmartObject; + smart_objects::SmartObject& so_to_send = *update_list; + so_to_send[jhs::S_PARAMS][jhs::S_FUNCTION_ID] = + hmi_apis::FunctionID::BasicCommunication_UpdateDeviceList; + so_to_send[jhs::S_PARAMS][jhs::S_MESSAGE_TYPE] = + hmi_apis::messageType::request; + so_to_send[jhs::S_PARAMS][jhs::S_PROTOCOL_VERSION] = 3; + so_to_send[jhs::S_PARAMS][jhs::S_PROTOCOL_TYPE] = 1; + so_to_send[jhs::S_PARAMS][jhs::S_CORRELATION_ID] = GetNextHMICorrelationID(); + smart_objects::SmartObject* msg_params = MessageHelper::CreateDeviceListSO( + device_list); + if (!msg_params) { + LOG4CXX_WARN(logger_, "Failed to create sub-smart object."); + delete update_list; + return; + } + so_to_send[jhs::S_MSG_PARAMS] = *msg_params; + ManageHMICommand(update_list); +} + +void ApplicationManagerImpl::OnFindNewApplicationsRequest() { + connection_handler_->ConnectToAllDevices(); + LOG4CXX_DEBUG(logger_, "Starting application list update timer"); + uint32_t timeout = profile::Profile::instance()->application_list_update_timeout(); + application_list_update_timer_->start(timeout); +} + +void ApplicationManagerImpl::SendUpdateAppList(const std::list<uint32_t>& applications_ids) { + LOG4CXX_TRACE(logger_, "SendUpdateAppList"); + + LOG4CXX_DEBUG(logger_, applications_ids.size() << " applications."); + + smart_objects::SmartObject* request = MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::BasicCommunication_UpdateAppList); + (*request)[strings::msg_params][strings::applications] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + + smart_objects::SmartObject& applications = + (*request)[strings::msg_params][strings::applications]; + + uint32_t app_count = 0; + for (std::list<uint32_t>::const_iterator it = applications_ids.begin(); + it != applications_ids.end(); ++it) { + ApplicationSharedPtr app = application(*it); + + if (!app.valid()) { + LOG4CXX_ERROR(logger_, "Application not found , id = " << *it); + continue; + } + + smart_objects::SmartObject hmi_application(smart_objects::SmartType_Map);; + if (!MessageHelper::CreateHMIApplicationStruct(app, hmi_application)) { + LOG4CXX_ERROR(logger_, "Can't CreateHMIApplicationStruct ', id = " << *it); + continue; + } + applications[app_count++] = hmi_application; + } + if (app_count <= 0) { + LOG4CXX_WARN(logger_, "Empty applications list"); + } + ManageHMICommand(request); +} + +void ApplicationManagerImpl::RemoveDevice( + const connection_handler::DeviceHandle& device_handle) { + LOG4CXX_INFO(logger_, "device_handle " << device_handle); +} + +bool ApplicationManagerImpl::IsAudioStreamingAllowed(uint32_t application_key) const { + ApplicationSharedPtr app = application(application_key); + + if (!app) { + LOG4CXX_WARN(logger_, "An application is not registered."); + return false; + } + + const mobile_api::HMILevel::eType& hmi_level = app->hmi_level(); + + if (mobile_api::HMILevel::HMI_FULL == hmi_level || + mobile_api::HMILevel::HMI_LIMITED == hmi_level) { + return true; + } + + return false; +} + +bool ApplicationManagerImpl::IsVideoStreamingAllowed(uint32_t application_key) const { + ApplicationSharedPtr app = application(application_key); + + if (!app) { + LOG4CXX_WARN(logger_, "An application is not registered."); + return false; + } + + const mobile_api::HMILevel::eType& hmi_level = app->hmi_level(); + + if (mobile_api::HMILevel::HMI_FULL == hmi_level && + app->hmi_supports_navi_video_streaming()) { + return true; + } + + return false; +} + +uint32_t ApplicationManagerImpl::GenerateGrammarID() { + return rand(); +} + +uint32_t ApplicationManagerImpl::GenerateNewHMIAppID() { + uint32_t hmi_app_id = rand(); + + while (resume_ctrl_.IsHMIApplicationIdExist(hmi_app_id)) { + hmi_app_id = rand(); + } + + return hmi_app_id; +} + +void ApplicationManagerImpl::ReplaceMobileByHMIAppId( + smart_objects::SmartObject& message) { + MessageHelper::PrintSmartObject(message); + flush(std::cout); + if (message.keyExists(strings::app_id)) { + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application( + message[strings::app_id].asUInt()); + if (application.valid()) { + LOG4CXX_INFO(logger_, "ReplaceMobileByHMIAppId from " << message[strings::app_id].asInt() + << " to " << application->hmi_app_id()); + message[strings::app_id] = application->hmi_app_id(); + } + } else { + switch (message.getType()) { + case smart_objects::SmartType::SmartType_Array: { + smart_objects::SmartArray* message_array = message.asArray(); + smart_objects::SmartArray::iterator it = message_array->begin(); + for(; it != message_array->end(); ++it) { + ReplaceMobileByHMIAppId(*it); + } + break; + } + case smart_objects::SmartType::SmartType_Map: { + std::set<std::string> keys = message.enumerate(); + std::set<std::string>::const_iterator key = keys.begin(); + for (; key != keys.end(); ++key) { + std::string k = *key; + ReplaceMobileByHMIAppId(message[*key]); + } + break; + } + default: { + break; + } + } + } +} + +void ApplicationManagerImpl::ReplaceHMIByMobileAppId( + smart_objects::SmartObject& message) { + if (message.keyExists(strings::app_id)) { + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application_by_hmi_app( + message[strings::app_id].asUInt()); + + if (application.valid()) { + LOG4CXX_INFO(logger_, "ReplaceHMIByMobileAppId from " << message[strings::app_id].asInt() + << " to " << application->app_id()); + message[strings::app_id] = application->app_id(); + } + } else { + switch (message.getType()) { + case smart_objects::SmartType::SmartType_Array: { + smart_objects::SmartArray* message_array = message.asArray(); + smart_objects::SmartArray::iterator it = message_array->begin(); + for(; it != message_array->end(); ++it) { + ReplaceHMIByMobileAppId(*it); + } + break; + } + case smart_objects::SmartType::SmartType_Map: { + std::set<std::string> keys = message.enumerate(); + std::set<std::string>::const_iterator key = keys.begin(); + for (; key != keys.end(); ++key) { + ReplaceHMIByMobileAppId(message[*key]); + } + break; + } + default: { + break; + } + } + } +} + +bool ApplicationManagerImpl::OnServiceStartedCallback( + const connection_handler::DeviceHandle& device_handle, + const int32_t& session_key, + const protocol_handler::ServiceType& type) { + LOG4CXX_INFO(logger_, + "OnServiceStartedCallback " << type << " in session " << session_key); + ApplicationSharedPtr app = application(session_key); + + switch (type) { + case protocol_handler::kRpc: { + LOG4CXX_INFO(logger_, "RPC service is about to be started."); + break; + } + case protocol_handler::kMobileNav: { + LOG4CXX_INFO(logger_, "Video service is about to be started."); + if (media_manager_) { + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "An application is not registered."); + return false; + } + if (app->allowed_support_navigation()) { + media_manager_->StartVideoStreaming(session_key); + } else { + return false; + } + } + break; + } + case protocol_handler::kAudio: { + LOG4CXX_INFO(logger_, "Audio service is about to be started."); + if (media_manager_) { + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "An application is not registered."); + return false; + } + if (app->allowed_support_navigation()) { + media_manager_->StartAudioStreaming(session_key); + } else { + return false; + } + } + break; + } + default: { + LOG4CXX_WARN(logger_, "Unknown type of service to be started."); + break; + } + } + + return true; +} + +void ApplicationManagerImpl::OnServiceEndedCallback(const int32_t& session_key, + const protocol_handler::ServiceType& type) { + LOG4CXX_INFO_EXT( + logger_, + "OnServiceEndedCallback " << type << " in session " << session_key); + + switch (type) { + case protocol_handler::kRpc: { + LOG4CXX_INFO(logger_, "Remove application."); + /* in case it was unexpected disconnect application will be removed + and we will notify HMI that it was unexpected disconnect, + but in case it was closed by mobile we will be unable to find it in the list + */ + UnregisterApplication(session_key, mobile_apis::Result::INVALID_ENUM, + true, true); + break; + } + case protocol_handler::kMobileNav: { + LOG4CXX_INFO(logger_, "Stop video streaming."); + if (media_manager_) { + media_manager_->StopVideoStreaming(session_key); + } + break; + } + case protocol_handler::kAudio: { + LOG4CXX_INFO(logger_, "Stop audio service."); + if (media_manager_) { + media_manager_->StopAudioStreaming(session_key); + } + break; + } + default: + LOG4CXX_WARN(logger_, "Unknown type of service to be ended." << + type); + break; + } +} + +void ApplicationManagerImpl::set_hmi_message_handler( + hmi_message_handler::HMIMessageHandler* handler) { + hmi_handler_ = handler; +} + +void ApplicationManagerImpl::set_connection_handler( + connection_handler::ConnectionHandler* handler) { + connection_handler_ = handler; +} + +connection_handler::ConnectionHandler* ApplicationManagerImpl::connection_handler() { + return connection_handler_; +} + +void ApplicationManagerImpl::set_protocol_handler( + protocol_handler::ProtocolHandler* handler) { + protocol_handler_ = handler; +} + +void ApplicationManagerImpl::StartDevicesDiscovery() { + connection_handler::ConnectionHandlerImpl::instance()-> + StartDevicesDiscovery(); +} + +void ApplicationManagerImpl::SendMessageToMobile( + const utils::SharedPtr<smart_objects::SmartObject>& message, + bool final_message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::SendMessageToMobile"); + + if (!message) { + LOG4CXX_ERROR(logger_, "Null-pointer message received."); + NOTREACHED(); + return; + } + + if (!protocol_handler_) { + LOG4CXX_WARN(logger_, "No Protocol Handler set"); + return; + } + + ApplicationSharedPtr app = application( + (*message)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, + "No application associated with connection key"); + if ((*message)[strings::msg_params].keyExists(strings::result_code) && + ((*message)[strings::msg_params][strings::result_code] == + NsSmartDeviceLinkRPC::V1::Result::UNSUPPORTED_VERSION)) { + (*message)[strings::params][strings::protocol_version] = + ProtocolVersion::kV1; + } else { + (*message)[strings::params][strings::protocol_version] = + ProtocolVersion::kV3; + } + } else { + (*message)[strings::params][strings::protocol_version] = + app->protocol_version(); + } + + mobile_so_factory().attachSchema(*message); + LOG4CXX_INFO( + logger_, + "Attached schema to message, result if valid: " << message->isValid()); + + // Messages to mobile are not yet prioritized so use default priority value + utils::SharedPtr<Message> message_to_send(new Message( + protocol_handler::MessagePriority::kDefault)); + if (!ConvertSOtoMessage((*message), (*message_to_send))) { + LOG4CXX_WARN(logger_, "Can't send msg to Mobile: failed to create string"); + return; + } + + smart_objects::SmartObject& msg_to_mobile = *message; + // If correlation_id is not present, it is from-HMI message which should be + // checked against policy permissions + if (msg_to_mobile[strings::params].keyExists(strings::correlation_id)) { + request_ctrl_.terminateMobileRequest( + msg_to_mobile[strings::params][strings::correlation_id].asInt()); + } else if (app) { + mobile_apis::FunctionID::eType function_id = + static_cast<mobile_apis::FunctionID::eType>( + (*message)[strings::params][strings::function_id].asUInt()); + RPCParams params; + + const smart_objects::SmartObject& s_map = (*message)[strings::msg_params]; + if (smart_objects::SmartType_Map == s_map.getType()) { + smart_objects::SmartMap::iterator iter = s_map.map_begin(); + smart_objects::SmartMap::iterator iter_end = s_map.map_end(); + + for (; iter != iter_end; ++iter) { + params.push_back(iter->first); + } + } + const mobile_apis::Result::eType check_result = + CheckPolicyPermissions( app->mobile_app_id()->asString(), + app->hmi_level(), function_id, params); + if (mobile_apis::Result::SUCCESS != check_result) { + const std::string string_functionID = + MessageHelper::StringifiedFunctionID(function_id); + LOG4CXX_WARN(logger_, "Function \"" << string_functionID << "\" (#" + << function_id << ") not allowed by policy"); + return; + } + + if (function_id == mobile_apis::FunctionID::OnSystemRequestID) { + policy::PolicyHandler::instance()->OnUpdateRequestSentToMobile(); + } + } + + messages_to_mobile_.PostMessage(impl::MessageToMobile(message_to_send, + final_message)); +} + +bool ApplicationManagerImpl::ManageMobileCommand( + const utils::SharedPtr<smart_objects::SmartObject>& message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ManageMobileCommand"); + + if (!message) { + LOG4CXX_WARN(logger_, "RET Null-pointer message received."); + NOTREACHED() + return false; + } + +#ifdef DEBUG + MessageHelper::PrintSmartObject(*message); +#endif + + LOG4CXX_INFO(logger_, "Trying to create message in mobile factory."); + commands::Command* command = MobileCommandFactory::CreateCommand(message); + + if (!command) { + LOG4CXX_WARN(logger_, "RET Failed to create mobile command from smart object"); + return false; + } + + mobile_apis::FunctionID::eType function_id = + static_cast<mobile_apis::FunctionID::eType>( + (*message)[strings::params][strings::function_id].asInt()); + + // Notifications from HMI have no such parameter + uint32_t correlation_id = + (*message)[strings::params].keyExists(strings::correlation_id) + ? (*message)[strings::params][strings::correlation_id].asUInt() + : 0; + + uint32_t connection_key = + (*message)[strings::params][strings::connection_key].asUInt(); + + int32_t protocol_type = + (*message)[strings::params][strings::protocol_type].asUInt(); + + ApplicationSharedPtr app; + int32_t message_type = (*message)[strings::params][strings::message_type].asInt(); + + if (((mobile_apis::FunctionID::RegisterAppInterfaceID != function_id) && + (protocol_type == commands::CommandImpl::mobile_protocol_type_)) && + (mobile_apis::FunctionID::UnregisterAppInterfaceID != function_id)) { + app = ApplicationManagerImpl::instance()->application(connection_key); + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "RET APPLICATION_NOT_REGISTERED"); + smart_objects::SmartObject* response = + MessageHelper::CreateNegativeResponse( + connection_key, + static_cast<int32_t>(function_id), + correlation_id, + static_cast<int32_t>(mobile_apis::Result::APPLICATION_NOT_REGISTERED)); + + SendMessageToMobile(response); + return false; + } + + // Message for "CheckPermission" must be with attached schema + mobile_so_factory().attachSchema(*message); + } + + if (message_type == + mobile_apis::messageType::response) { + if (command->Init()) { + command->Run(); + command->CleanUp(); + } + delete command; + return true; + } + if (message_type == + mobile_apis::messageType::notification) { + commands::CommandNotificationImpl* command_notify = + static_cast<commands::CommandNotificationImpl*>(command); + request_ctrl_.addNotification(command_notify); + if (command_notify->Init()) { + command_notify->Run(); + if (command_notify->CleanUp()) { + request_ctrl_.removeNotification(command_notify); + } + // If CleanUp returned false notification should remove it self. + } + return true; + } + + if (message_type == + mobile_apis::messageType::request) { + + commands::CommandRequestImpl* command_request = + static_cast<commands::CommandRequestImpl*>(command); + // commands will be launched from requesr_ctrl + mobile_apis::HMILevel::eType app_hmi_level = mobile_apis::HMILevel::INVALID_ENUM; + if (app) { + app_hmi_level = app->hmi_level(); + } + + // commands will be launched from request_ctrl + + request_controller::RequestController::TResult result = + request_ctrl_.addMobileRequest(command_request, app_hmi_level); + + if (result == request_controller::RequestController::SUCCESS) { + LOG4CXX_INFO(logger_, "Perform request"); + } else if (result == + request_controller::RequestController:: + TOO_MANY_PENDING_REQUESTS) { + LOG4CXX_ERROR_EXT(logger_, "RET Unable top perform request: " << + "TOO_MANY_PENDING_REQUESTS"); + + smart_objects::SmartObject* response = + MessageHelper::CreateNegativeResponse( + connection_key, + static_cast<int32_t>(function_id), + correlation_id, + static_cast<int32_t>(mobile_apis::Result::TOO_MANY_PENDING_REQUESTS)); + + SendMessageToMobile(response); + return false; + } else if (result == + request_controller::RequestController::TOO_MANY_REQUESTS) { + LOG4CXX_ERROR_EXT(logger_, "RET Unable to perform request: " << + "TOO_MANY_REQUESTS"); + + MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + connection_key, + mobile_api::AppInterfaceUnregisteredReason::TOO_MANY_REQUESTS); + + UnregisterApplication(connection_key, + mobile_apis::Result::TOO_MANY_PENDING_REQUESTS, + false); + return false; + } else if (result == + request_controller::RequestController:: + NONE_HMI_LEVEL_MANY_REQUESTS) { + LOG4CXX_ERROR_EXT(logger_, "RET Unable to perform request: " << + "REQUEST_WHILE_IN_NONE_HMI_LEVEL"); + + MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + connection_key, mobile_api::AppInterfaceUnregisteredReason:: + REQUEST_WHILE_IN_NONE_HMI_LEVEL); + + application(connection_key)->usage_report().RecordRemovalsForBadBehavior(); + UnregisterApplication(connection_key, mobile_apis::Result::INVALID_ENUM, + false); + return false; + } else { + LOG4CXX_ERROR_EXT(logger_, "RET Unable to perform request: Unknown case"); + return false; + } + return true; + } + + LOG4CXX_ERROR(logger_, "RET UNKNOWN MESSAGE TYPE " << message_type); + return false; +} + +void ApplicationManagerImpl::SendMessageToHMI( + const utils::SharedPtr<smart_objects::SmartObject>& message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::SendMessageToHMI"); + + if (!message) { + LOG4CXX_WARN(logger_, "Null-pointer message received."); + NOTREACHED(); + return; + } + + if (!hmi_handler_) { + LOG4CXX_WARN(logger_, "No HMI Handler set"); + return; + } + + // SmartObject |message| has no way to declare priority for now + utils::SharedPtr<Message> message_to_send( + new Message(protocol_handler::MessagePriority::kDefault)); + if (!message_to_send) { + LOG4CXX_ERROR(logger_, "Null pointer"); + return; + } + + hmi_so_factory().attachSchema(*message); + LOG4CXX_INFO( + logger_, + "Attached schema to message, result if valid: " << message->isValid()); + + +#ifdef HMI_DBUS_API + message_to_send->set_smart_object(*message); +#else + if (!ConvertSOtoMessage(*message, *message_to_send)) { + LOG4CXX_WARN(logger_, + "Cannot send message to HMI: failed to create string"); + return; + } +#endif // HMI_DBUS_API + + messages_to_hmi_.PostMessage(impl::MessageToHmi(message_to_send)); +} + +bool ApplicationManagerImpl::ManageHMICommand( + const utils::SharedPtr<smart_objects::SmartObject>& message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ManageHMICommand"); + + if (!message) { + LOG4CXX_WARN(logger_, "Null-pointer message received."); + NOTREACHED(); + return false; + } + + + MessageHelper::PrintSmartObject(*message); + + CommandSharedPtr command = HMICommandFactory::CreateCommand(message); + if (!command) { + LOG4CXX_WARN(logger_, "Failed to create command from smart object"); + return false; + } + + int32_t message_type = (*(message.get()))[strings::params][strings::message_type].asInt(); + + if (kRequest == message_type) { + LOG4CXX_DEBUG(logger_, "ManageHMICommand"); + request_ctrl_.addHMIRequest(command); + } + + if (command->Init()) { + command->Run(); + if (kResponse == message_type) { + int32_t correlation_id = (*(message.get()))[strings::params][strings::correlation_id].asInt(); + request_ctrl_.terminateHMIRequest(correlation_id); + } + return true; + } + return false; +} + +bool ApplicationManagerImpl::Init() { + LOG4CXX_TRACE(logger_, "Init application manager"); + if (policy::PolicyHandler::instance()->PolicyEnabled()) { + if(!policy::PolicyHandler::instance()->LoadPolicyLibrary()) { + LOG4CXX_ERROR(logger_, "Policy library is not loaded. Check LD_LIBRARY_PATH"); + return false; + } + LOG4CXX_INFO(logger_, "Policy library is loaded, now initing PT"); + if (!policy::PolicyHandler::instance()->InitPolicyTable()) { + LOG4CXX_ERROR(logger_, "Policy table is not initialized."); + return false; + } + } else { + LOG4CXX_WARN(logger_, "System is configured to work without policy functionality."); + } + const std::string app_storage_folder = + profile::Profile::instance()->app_storage_folder(); + if (!file_system::DirectoryExists(app_storage_folder)) { + LOG4CXX_WARN(logger_, "Storage directory doesn't exist"); + // if storage directory doesn't exist try to create it + if (!file_system::CreateDirectoryRecursively(app_storage_folder)) { + LOG4CXX_ERROR(logger_, "Unable to create Storage directory " + << app_storage_folder); + return false; + } + } + if (!(file_system::IsWritingAllowed(app_storage_folder) && + file_system::IsReadingAllowed(app_storage_folder))) { + LOG4CXX_ERROR(logger_, + "Storage directory doesn't have read/write permissions"); + return false; + } + + const std::string system_files_path = + profile::Profile::instance()->system_files_path(); + if (!file_system::DirectoryExists(system_files_path)) { + LOG4CXX_WARN(logger_, "System files directory doesn't exist"); + // if system directory doesn't exist try to create it + if (!file_system::CreateDirectoryRecursively(system_files_path)) { + LOG4CXX_ERROR(logger_, "Unable to create System directory " + << system_files_path); + return false; + } + } + if (!(file_system::IsWritingAllowed(system_files_path) && + file_system::IsReadingAllowed(system_files_path))) { + LOG4CXX_ERROR(logger_, + "System directory doesn't have read/write permissions"); + return false; + } + media_manager_ = media_manager::MediaManagerImpl::instance(); + return true; +} + +bool ApplicationManagerImpl::ConvertMessageToSO( + const Message& message, smart_objects::SmartObject& output) { + LOG4CXX_INFO( + logger_, + "\t\t\tMessage to convert: protocol " << message.protocol_version() + << "; json " << message.json_message()); + + switch (message.protocol_version()) { + case ProtocolVersion::kV3: + case ProtocolVersion::kV2: { + const bool conversion_result = + formatters::CFormatterJsonSDLRPCv2::fromString( + message.json_message(), output, message.function_id(), + message.type(), message.correlation_id()); + if (!conversion_result + || !mobile_so_factory().attachSchema(output) + || ((output.validate() != smart_objects::Errors::OK)) ) { + LOG4CXX_WARN(logger_, "Failed to parse string to smart object :" + << message.json_message()); + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + message.connection_key(), message.function_id(), + message.correlation_id(), mobile_apis::Result::INVALID_DATA)); + ManageMobileCommand(response); + return false; + } + LOG4CXX_INFO( + logger_, + "Convertion result for sdl object is true" << " function_id " + << output[jhs::S_PARAMS][jhs::S_FUNCTION_ID].asInt()); + output[strings::params][strings::connection_key] = + message.connection_key(); + output[strings::params][strings::protocol_version] = + message.protocol_version(); + if (message.binary_data()) { + if (message.payload_size() < message.data_size()) { + LOG4CXX_ERROR(logger_, "Incomplete binary" << + " binary size should be " << message.data_size() << + " payload data size is " << message.payload_size()); + utils::SharedPtr<smart_objects::SmartObject> response( + MessageHelper::CreateNegativeResponse( + message.connection_key(), message.function_id(), + message.correlation_id(), mobile_apis::Result::INVALID_DATA)); + ManageMobileCommand(response); + return false; + } + output[strings::params][strings::binary_data] = + *(message.binary_data()); + } + break; + } + case ProtocolVersion::kHMI: { +#ifdef ENABLE_LOG + int32_t result = +#endif + formatters::FormatterJsonRpc::FromString < + hmi_apis::FunctionID::eType, hmi_apis::messageType::eType > ( + message.json_message(), output); + LOG4CXX_INFO( + logger_, + "Convertion result: " << result << " function id " + << output[jhs::S_PARAMS][jhs::S_FUNCTION_ID].asInt()); + if (!hmi_so_factory().attachSchema(output)) { + LOG4CXX_WARN(logger_, "Failed to attach schema to object."); + return false; + } + if (output.validate() != smart_objects::Errors::OK) { + LOG4CXX_WARN(logger_, "Incorrect parameter from HMI"); + output.erase(strings::msg_params); + output[strings::params][hmi_response::code] = + hmi_apis::Common_Result::INVALID_DATA; + output[strings::msg_params][strings::info] = + std::string("Received invalid data on HMI response"); + } + break; + } + case ProtocolVersion::kV1: { + static NsSmartDeviceLinkRPC::V1::v4_protocol_v1_2_no_extra v1_shema; + + if (message.function_id() == 0 || message.type() == kUnknownType) { + LOG4CXX_ERROR(logger_, "Message received: UNSUPPORTED_VERSION"); + + int32_t conversation_result = + formatters::CFormatterJsonSDLRPCv1::fromString < + NsSmartDeviceLinkRPC::V1::FunctionID::eType, + NsSmartDeviceLinkRPC::V1::messageType::eType > ( + message.json_message(), output); + + if (formatters::CFormatterJsonSDLRPCv1::kSuccess + == conversation_result) { + + smart_objects::SmartObject params = smart_objects::SmartObject(smart_objects::SmartType::SmartType_Map); + + output[strings::params][strings::message_type] = + NsSmartDeviceLinkRPC::V1::messageType::response; + output[strings::params][strings::connection_key] = message.connection_key(); + + output[strings::msg_params] = + smart_objects::SmartObject(smart_objects::SmartType::SmartType_Map); + output[strings::msg_params][strings::success] = false; + output[strings::msg_params][strings::result_code] = + NsSmartDeviceLinkRPC::V1::Result::UNSUPPORTED_VERSION; + + smart_objects::SmartObject* msg_to_send = new smart_objects::SmartObject(output); + v1_shema.attachSchema(*msg_to_send); + SendMessageToMobile(msg_to_send); + return false; + } + } + + break; + } + default: + // TODO(PV): + // removed NOTREACHED() because some app can still have vesion 1. + LOG4CXX_WARN( + logger_, + "Application used unsupported protocol :" << message.protocol_version() + << "."); + return false; + } + + LOG4CXX_INFO(logger_, "Successfully parsed message into smart object"); + return true; +} + +bool ApplicationManagerImpl::ConvertSOtoMessage( + const smart_objects::SmartObject& message, Message& output) { + LOG4CXX_INFO(logger_, "Message to convert"); + + if (smart_objects::SmartType_Null == message.getType() + || smart_objects::SmartType_Invalid == message.getType()) { + LOG4CXX_WARN(logger_, "Invalid smart object received."); + return false; + } + + LOG4CXX_INFO( + logger_, + "Message with protocol: " + << message.getElement(jhs::S_PARAMS).getElement(jhs::S_PROTOCOL_TYPE) + .asInt()); + + std::string output_string; + switch (message.getElement(jhs::S_PARAMS).getElement(jhs::S_PROTOCOL_TYPE) + .asInt()) { + case 0: { + if (message.getElement(jhs::S_PARAMS).getElement(jhs::S_PROTOCOL_VERSION).asInt() == 1) { + if (!formatters::CFormatterJsonSDLRPCv1::toString(message, + output_string)) { + LOG4CXX_WARN(logger_, "Failed to serialize smart object"); + return false; + } + output.set_protocol_version(application_manager::kV1); + } else { + if (!formatters::CFormatterJsonSDLRPCv2::toString(message, + output_string)) { + LOG4CXX_WARN(logger_, "Failed to serialize smart object"); + return false; + } + output.set_protocol_version( + static_cast<ProtocolVersion>( + message.getElement(jhs::S_PARAMS).getElement( + jhs::S_PROTOCOL_VERSION).asUInt())); + } + + break; + } + case 1: { + if (!formatters::FormatterJsonRpc::ToString(message, output_string)) { + LOG4CXX_WARN(logger_, "Failed to serialize smart object"); + return false; + } + output.set_protocol_version(application_manager::kHMI); + break; + } + default: + NOTREACHED(); + return false; + } + + LOG4CXX_INFO(logger_, "Convertion result: " << output_string); + + output.set_connection_key( + message.getElement(jhs::S_PARAMS).getElement(strings::connection_key) + .asInt()); + + output.set_function_id( + message.getElement(jhs::S_PARAMS).getElement(jhs::S_FUNCTION_ID).asInt()); + + output.set_correlation_id( + message.getElement(jhs::S_PARAMS).getElement(jhs::S_CORRELATION_ID) + .asInt()); + output.set_message_type( + static_cast<MessageType>(message.getElement(jhs::S_PARAMS).getElement( + jhs::S_MESSAGE_TYPE).asInt())); + + // Currently formatter creates JSON = 3 bytes for empty SmartObject. + // workaround for notification. JSON must be empty + if (mobile_apis::FunctionID::OnAudioPassThruID + != message.getElement(jhs::S_PARAMS).getElement(strings::function_id) + .asInt()) { + output.set_json_message(output_string); + } + + if (message.getElement(jhs::S_PARAMS).keyExists(strings::binary_data)) { + application_manager::BinaryData* binaryData = + new application_manager::BinaryData( + message.getElement(jhs::S_PARAMS).getElement(strings::binary_data) + .asBinary()); + + if (NULL == binaryData) { + LOG4CXX_ERROR(logger_, "Null pointer"); + return false; + } + output.set_binary_data(binaryData); + } + + LOG4CXX_INFO(logger_, "Successfully parsed smart object into message"); + return true; +} + +utils::SharedPtr<Message> ApplicationManagerImpl::ConvertRawMsgToMessage( + const RawMessagePtr message) { + DCHECK(message); + utils::SharedPtr<Message> outgoing_message; + + LOG4CXX_INFO(logger_, "Service type." << message->service_type()); + + if (message->service_type() != protocol_handler::kRpc + && + message->service_type() != protocol_handler::kBulk) { + // skip this message, not under handling of ApplicationManager + LOG4CXX_TRACE(logger_, "Skipping message; not the under AM handling."); + return outgoing_message; + } + + Message* convertion_result = NULL; + if (message->protocol_version() == 1) { + convertion_result = + MobileMessageHandler::HandleIncomingMessageProtocolV1(message); + } else if ((message->protocol_version() == 2) || + (message->protocol_version() == 3)) { + convertion_result = + MobileMessageHandler::HandleIncomingMessageProtocolV2(message); + } else { + LOG4CXX_WARN(logger_, "Unknown protocol version."); + return outgoing_message; + } + + if (convertion_result) { + outgoing_message = convertion_result; + } else { + LOG4CXX_ERROR(logger_, "Received invalid message"); + } + return outgoing_message; +} + +void ApplicationManagerImpl::ProcessMessageFromMobile( + const utils::SharedPtr<Message>& message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ProcessMessageFromMobile()"); +#ifdef TIME_TESTER + AMMetricObserver::MessageMetricSharedPtr metric(new AMMetricObserver::MessageMetric()); + metric->begin = date_time::DateTime::getCurrentTime(); +#endif // TIME_TESTER + utils::SharedPtr<smart_objects::SmartObject> so_from_mobile( + new smart_objects::SmartObject); + + if (!so_from_mobile) { + LOG4CXX_ERROR(logger_, "Null pointer"); + return; + } + + if (!ConvertMessageToSO(*message, *so_from_mobile)) { + LOG4CXX_ERROR(logger_, "Cannot create smart object from message"); + return; + } +#ifdef TIME_TESTER + metric->message = so_from_mobile; +#endif // TIME_TESTER + + if (!ManageMobileCommand(so_from_mobile)) { + LOG4CXX_ERROR(logger_, "Received command didn't run successfully"); + } +#ifdef TIME_TESTER + metric->end = date_time::DateTime::getCurrentTime(); + if (metric_observer_) { + metric_observer_->OnMessage(metric); + } +#endif // TIME_TESTER +} + +void ApplicationManagerImpl::ProcessMessageFromHMI( + const utils::SharedPtr<Message>& message) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::ProcessMessageFromHMI()"); + utils::SharedPtr<smart_objects::SmartObject> smart_object( + new smart_objects::SmartObject); + + if (!smart_object) { + LOG4CXX_ERROR(logger_, "Null pointer"); + return; + } + +#ifdef HMI_DBUS_API + *smart_object = message->smart_object(); +#else + if (!ConvertMessageToSO(*message, *smart_object)) { + LOG4CXX_ERROR(logger_, "Cannot create smart object from message"); + return; + } +#endif // HMI_DBUS_API + + LOG4CXX_INFO(logger_, "Converted message, trying to create hmi command"); + if (!ManageHMICommand(smart_object)) { + LOG4CXX_ERROR(logger_, "Received command didn't run successfully"); + } +} + +hmi_apis::HMI_API& ApplicationManagerImpl::hmi_so_factory() { + if (!hmi_so_factory_) { + hmi_so_factory_ = new hmi_apis::HMI_API; + if (!hmi_so_factory_) { + LOG4CXX_ERROR(logger_, "Out of memory"); + NOTREACHED(); + } + } + return *hmi_so_factory_; +} + +mobile_apis::MOBILE_API& ApplicationManagerImpl::mobile_so_factory() { + if (!mobile_so_factory_) { + mobile_so_factory_ = new mobile_apis::MOBILE_API; + if (!mobile_so_factory_) { + LOG4CXX_ERROR(logger_, "Out of memory."); + NOTREACHED(); + } + } + return *mobile_so_factory_; +} + +HMICapabilities& ApplicationManagerImpl::hmi_capabilities() { + return hmi_capabilities_; +} + +#ifdef TIME_TESTER +void ApplicationManagerImpl::SetTimeMetricObserver(AMMetricObserver* observer) { + metric_observer_ = observer; +} +#endif // TIME_TESTER + +void ApplicationManagerImpl::addNotification(const CommandSharedPtr ptr) { + request_ctrl_.addNotification(ptr); +} + +void ApplicationManagerImpl::removeNotification(const commands::Command* notification) { + request_ctrl_.removeNotification(notification); +} + +void ApplicationManagerImpl::updateRequestTimeout(uint32_t connection_key, + uint32_t mobile_correlation_id, + uint32_t new_timeout_value) { + request_ctrl_.updateRequestTimeout(connection_key, mobile_correlation_id, + new_timeout_value); +} + +const uint32_t ApplicationManagerImpl::application_id +(const int32_t correlation_id) { + // ykazakov: there is no erase for const iterator for QNX + std::map<const int32_t, const uint32_t>::iterator it = + appID_list_.find(correlation_id); + if (appID_list_.end() != it) { + const uint32_t app_id = it->second; + appID_list_.erase(it); + return app_id; + } else { + return 0; + } +} + +void ApplicationManagerImpl::set_application_id(const int32_t correlation_id, + const uint32_t app_id) { + appID_list_.insert(std::pair<const int32_t, const uint32_t> + (correlation_id, app_id)); +} + +void ApplicationManagerImpl::SetUnregisterAllApplicationsReason( + mobile_api::AppInterfaceUnregisteredReason::eType reason) { + unregister_reason_ = reason; +} + +void ApplicationManagerImpl::HeadUnitReset( + mobile_api::AppInterfaceUnregisteredReason::eType reason) { + switch (reason) { + case mobile_api::AppInterfaceUnregisteredReason::MASTER_RESET: { + file_system::remove_directory_content(profile::Profile::instance()->app_storage_folder()); + resume_controller().ClearResumptionInfo(); + policy::PolicyHandler::instance()->ResetPolicyTable(); + break; + } + case mobile_api::AppInterfaceUnregisteredReason::FACTORY_DEFAULTS: { + policy::PolicyHandler::instance()->ClearUserConsent(); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Bad AppInterfaceUnregisteredReason"); + return; + } + } +} + +void ApplicationManagerImpl::HeadUnitSuspend() { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::HeadUnitSuspend"); +} + +void ApplicationManagerImpl::SendOnSDLClose() { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::SendOnSDLClose"); + + // must be sent to PASA HMI on shutdown synchronously + smart_objects::SmartObject* msg = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + (*msg)[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_OnSDLClose; + (*msg)[strings::params][strings::message_type] = + MessageType::kNotification; + (*msg)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*msg)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + + if (!msg) { + LOG4CXX_WARN(logger_, "Null-pointer message received."); + NOTREACHED(); + return; + } + + // SmartObject |message| has no way to declare priority for now + utils::SharedPtr<Message> message_to_send( + new Message(protocol_handler::MessagePriority::kDefault)); + + hmi_so_factory().attachSchema(*msg); + LOG4CXX_INFO( + logger_, + "Attached schema to message, result if valid: " << msg->isValid()); + + +#ifdef HMI_DBUS_API + message_to_send->set_smart_object(*msg); +#else + if (!ConvertSOtoMessage(*msg, *message_to_send)) { + LOG4CXX_WARN(logger_, + "Cannot send message to HMI: failed to create string"); + return; + } +#endif // HMI_DBUS_API + + if (!hmi_handler_) { + LOG4CXX_WARN(logger_, "No HMI Handler set"); + return; + } + + delete msg; + hmi_handler_->SendMessageToHMI(message_to_send); +} + +void ApplicationManagerImpl::UnregisterAllApplications(bool generated_by_hmi) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::UnregisterAllApplications " << + unregister_reason_); + + hmi_cooperating_ = false; + + bool is_ignition_off = + unregister_reason_ == + mobile_api::AppInterfaceUnregisteredReason::IGNITION_OFF ? true : false; + + bool is_unexpected_disconnect = (generated_by_hmi != true); + + sync_primitives::AutoLock lock(applications_list_lock_); + + std::set<ApplicationSharedPtr>::iterator it = application_list_.begin(); + while (it != application_list_.end()) { + ApplicationSharedPtr app_to_remove = *it; + MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + app_to_remove->app_id(), unregister_reason_); + UnregisterApplication(app_to_remove->app_id(), + mobile_apis::Result::INVALID_ENUM, is_ignition_off, + is_unexpected_disconnect); + + connection_handler_->CloseSession(app_to_remove->app_id()); + it = application_list_.begin(); + } + + if (is_ignition_off) { + resume_controller().IgnitionOff(); + } + request_ctrl_.terminateAllHMIRequests(); +} + +void ApplicationManagerImpl::UnregisterApplication( + const uint32_t& app_id, mobile_apis::Result::eType reason, + bool is_resuming, bool is_unexpected_disconnect) { + LOG4CXX_INFO(logger_, + "ApplicationManagerImpl::UnregisterApplication " << app_id); + //remove appID from tts_global_properties_app_list_ + RemoveAppFromTTSGlobalPropertiesList(app_id); + + sync_primitives::AutoLock lock(applications_list_lock_); + + switch (reason) { + case mobile_apis::Result::SUCCESS:break; + case mobile_apis::Result::DISALLOWED: break; + case mobile_apis::Result::USER_DISALLOWED:break; + case mobile_apis::Result::INVALID_CERT: break; + case mobile_apis::Result::EXPIRED_CERT: break; + case mobile_apis::Result::TOO_MANY_PENDING_REQUESTS: { + application(app_id)->usage_report().RecordRemovalsForBadBehavior(); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Unknown unregister reason " << reason); + break; + } + } + + ApplicationSharedPtr app_to_remove; + std::set<ApplicationSharedPtr>::const_iterator it = application_list_.begin(); + for (; it != application_list_.end(); ++it) { + if ((*it)->app_id() == app_id) { + app_to_remove = *it; + break; + } + } + if (!app_to_remove) { + LOG4CXX_ERROR(logger_, "Cant find application with app_id = " << app_id); + return; + } + application_list_.erase(app_to_remove); + + if (is_resuming) { + resume_ctrl_.SaveApplication(app_to_remove); + } + + if (audio_pass_thru_active_) { + // May be better to put this code in MessageHelper? + end_audio_pass_thru(); + StopAudioPassThru(app_id); + MessageHelper::SendStopAudioPathThru(); + } + MessageHelper::SendOnAppUnregNotificationToHMI(app_to_remove, + is_unexpected_disconnect); + + request_ctrl_.terminateAppRequests(app_id); + return; +} + + +void ApplicationManagerImpl::UnregisterRevokedApplication( + const uint32_t& app_id, mobile_apis::Result::eType reason) { + UnregisterApplication(app_id, reason); + + connection_handler_->CloseSession(app_id); + + if (application_list_.empty()) { + connection_handler_->CloseRevokedConnection(app_id); + } +} + +void ApplicationManagerImpl::Handle(const impl::MessageFromMobile message) { + LOG4CXX_INFO(logger_, "Received message from Mobile side"); + + if (!message) { + LOG4CXX_ERROR(logger_, "Null-pointer message received."); + return; + } + ProcessMessageFromMobile(message); +} + +void ApplicationManagerImpl::Handle(const impl::MessageToMobile message) { + protocol_handler::RawMessage* rawMessage = 0; + if (message->protocol_version() == application_manager::kV1) { + rawMessage = MobileMessageHandler::HandleOutgoingMessageProtocolV1(message); + } else if ((message->protocol_version() == application_manager::kV2) || + (message->protocol_version() == application_manager::kV3)) { + rawMessage = MobileMessageHandler::HandleOutgoingMessageProtocolV2(message); + } else { + return; + } + if (!rawMessage) { + LOG4CXX_ERROR(logger_, "Failed to create raw message."); + return; + } + + if (!protocol_handler_) { + LOG4CXX_WARN(logger_, + "Protocol Handler is not set; cannot send message to mobile."); + return; + } + + + bool is_final = message.is_final; + bool close_session = false; + if (is_final) { + if (1 < connection_handler_->GetConnectionSessionsCount(message->connection_key())) { + is_final = false; + close_session = true; + } + } + + protocol_handler_->SendMessageToMobileApp(rawMessage, is_final); + LOG4CXX_INFO(logger_, "Message for mobile given away"); + + if (close_session) { + connection_handler_->CloseSession(message->connection_key()); + } +} + +void ApplicationManagerImpl::Handle(const impl::MessageFromHmi message) { + LOG4CXX_INFO(logger_, "Received message from hmi"); + + if (!message) { + LOG4CXX_ERROR(logger_, "Null-pointer message received."); + return; + } + + ProcessMessageFromHMI(message); +} + +void ApplicationManagerImpl::Handle(const impl::MessageToHmi message) { + LOG4CXX_INFO(logger_, "Received message to hmi"); + if (!hmi_handler_) { + LOG4CXX_ERROR(logger_, "Observer is not set for HMIMessageHandler"); + return; + } + + hmi_handler_->SendMessageToHMI(message); + LOG4CXX_INFO(logger_, "Message to hmi given away."); +} + +mobile_apis::Result::eType ApplicationManagerImpl::CheckPolicyPermissions( + const std::string& policy_app_id, + mobile_apis::HMILevel::eType hmi_level, + mobile_apis::FunctionID::eType function_id, + const RPCParams& rpc_params, + CommandParametersPermissions* params_permissions) { + LOG4CXX_INFO(logger_, "CheckPolicyPermissions"); + // TODO(AOleynik): Remove check of policy_enable, when this flag will be + // unused in config file + if (!policy::PolicyHandler::instance()->PolicyEnabled()) { + return mobile_apis::Result::SUCCESS; + } + + const std::string stringified_functionID = + MessageHelper::StringifiedFunctionID(function_id); + const std::string stringified_hmi_level = + MessageHelper::StringifiedHMILevel(hmi_level); + LOG4CXX_INFO( + logger_, + "Checking permissions for " << policy_app_id << + " in " << stringified_hmi_level << + " rpc " << stringified_functionID); + policy::CheckPermissionResult result; + policy::PolicyHandler::instance()->CheckPermissions( + policy_app_id, + stringified_hmi_level, + stringified_functionID, + rpc_params, + result); + + if (NULL != params_permissions) { + params_permissions->allowed_params = result.list_of_allowed_params; + params_permissions->disallowed_params = result.list_of_disallowed_params; + params_permissions->undefined_params = result.list_of_undefined_params; + } + + if (hmi_level == mobile_apis::HMILevel::HMI_NONE + && function_id != mobile_apis::FunctionID::UnregisterAppInterfaceID) { + ApplicationSharedPtr app = application_by_policy_id(policy_app_id); + if (!app) { + LOG4CXX_ERROR(logger_, "No application for policy id " << policy_app_id); + return mobile_apis::Result::GENERIC_ERROR; + } + if (result.hmi_level_permitted != policy::kRpcAllowed) { + app->usage_report().RecordRpcSentInHMINone(); + } + } + + const std::string log_msg = "Application: "+ policy_app_id+ + ", RPC: "+stringified_functionID+ + ", HMI status: "+stringified_hmi_level; + + if (result.hmi_level_permitted != policy::kRpcAllowed) { + LOG4CXX_WARN(logger_, "Request is blocked by policies. " << log_msg ); + + application_by_policy_id(policy_app_id)-> + usage_report().RecordPolicyRejectedRpcCall(); + + switch (result.hmi_level_permitted) { + case policy::kRpcDisallowed: + return mobile_apis::Result::DISALLOWED; + case policy::kRpcUserDisallowed: + return mobile_apis::Result::USER_DISALLOWED; + default: + return mobile_apis::Result::INVALID_ENUM; + } + } + LOG4CXX_INFO(logger_, "Request is allowed by policies. "+log_msg); + return mobile_api::Result::SUCCESS; +} + +void ApplicationManagerImpl::Mute(VRTTSSessionChanging changing_state) { + mobile_apis::AudioStreamingState::eType state = + hmi_capabilities_.attenuated_supported() + ? mobile_apis::AudioStreamingState::ATTENUATED + : mobile_apis::AudioStreamingState::NOT_AUDIBLE; + ApplicationManagerImpl::ApplicationListAccessor accessor; + ApplicationManagerImpl::TAppList local_app_list = accessor.applications(); + + ApplicationManagerImpl::TAppListConstIt it = local_app_list.begin(); + ApplicationManagerImpl::TAppListConstIt itEnd = local_app_list.end(); + for (; it != itEnd; ++it) { + if ((*it).valid()) { + if ((*it)->is_media_application()) { + if (kTTSSessionChanging == changing_state) { + (*it)->set_tts_speak_state(true); + } + if ((*it)->audio_streaming_state() != state && + (mobile_api::HMILevel::HMI_NONE != (*it)->hmi_level()) && + (mobile_api::HMILevel::HMI_BACKGROUND != (*it)->hmi_level())) { + (*it)->set_audio_streaming_state(state); + MessageHelper::SendHMIStatusNotification(*(*it)); + } + } + } + } +} + +void ApplicationManagerImpl::Unmute(VRTTSSessionChanging changing_state) { + + ApplicationManagerImpl::ApplicationListAccessor accessor; + ApplicationManagerImpl::TAppList local_app_list = application_list_; + ApplicationManagerImpl::TAppListConstIt it = local_app_list.begin(); + ApplicationManagerImpl::TAppListConstIt itEnd = local_app_list.end(); + + for (; it != itEnd; ++it) { + if ((*it).valid()) { + if ((*it)->is_media_application()) { + if (kTTSSessionChanging == changing_state) { + (*it)->set_tts_speak_state(false); + } + if ((!(vr_session_started())) && + (!((*it)->tts_speak_state())) && + ((*it)->audio_streaming_state() != + mobile_apis::AudioStreamingState::AUDIBLE) && + (mobile_api::HMILevel::HMI_NONE != (*it)->hmi_level()) && + (mobile_api::HMILevel::HMI_BACKGROUND != (*it)->hmi_level())) { + (*it)->set_audio_streaming_state( + mobile_apis::AudioStreamingState::AUDIBLE); + MessageHelper::SendHMIStatusNotification(*(*it)); + } + } + } + } +} + +mobile_apis::Result::eType ApplicationManagerImpl::SaveBinary( + const std::vector<uint8_t>& binary_data, const std::string& file_path, + const std::string& file_name, const int64_t offset) { + LOG4CXX_INFO(logger_, + "SaveBinaryWithOffset binary_size = " << binary_data.size() + << " offset = " << offset); + + if (binary_data.size() > file_system::GetAvailableDiskSpace(file_path)) { + LOG4CXX_ERROR(logger_, "Out of free disc space."); + return mobile_apis::Result::OUT_OF_MEMORY; + } + + const std::string full_file_path = file_path + "/" + file_name; + int64_t file_size = file_system::FileSize(full_file_path); + std::ofstream* file_stream; + if (offset != 0) { + if (file_size != offset) { + LOG4CXX_INFO(logger_, + "ApplicationManagerImpl::SaveBinaryWithOffset offset" + << " does'n match existing file size"); + return mobile_apis::Result::INVALID_DATA; + } + file_stream = file_system::Open(full_file_path, std::ios_base::app); + } else { + LOG4CXX_INFO( + logger_, + "ApplicationManagerImpl::SaveBinaryWithOffset offset is 0, rewrite"); + // if offset == 0: rewrite file + file_stream = file_system::Open(full_file_path, std::ios_base::out); + } + + if (!file_system::Write(file_stream, binary_data.data(), + binary_data.size())) { + file_system::Close(file_stream); + return mobile_apis::Result::GENERIC_ERROR; + } + + file_system::Close(file_stream); + LOG4CXX_INFO(logger_, "Successfully write data to file"); + return mobile_apis::Result::SUCCESS; +} + +uint32_t ApplicationManagerImpl::GetAvailableSpaceForApp( + const std::string& folder_name) { + const uint32_t app_quota = profile::Profile::instance()->app_dir_quota(); + std::string app_storage_path = + profile::Profile::instance()->app_storage_folder(); + + app_storage_path += "/"; + app_storage_path += folder_name; + + if (file_system::DirectoryExists(app_storage_path)) { + size_t size_of_directory = file_system::DirectorySize(app_storage_path); + if (app_quota < size_of_directory) { + return 0; + } + + uint32_t current_app_quota = app_quota - size_of_directory; + uint32_t available_disk_space = + file_system::GetAvailableDiskSpace(app_storage_path); + + if (current_app_quota > available_disk_space) { + return available_disk_space; + } else { + return current_app_quota; + } + } else { + return app_quota; + } +} + +bool ApplicationManagerImpl::IsHMICooperating() const { + return hmi_cooperating_; +} + +void ApplicationManagerImpl::OnApplicationListUpdateTimer() { + LOG4CXX_DEBUG(logger_, "Application list update timer finished"); + + std::list <uint32_t> applications_ids; + + applications_list_lock_.Acquire(); + for (std::set<ApplicationSharedPtr>::const_iterator i = application_list_.begin(); + i != application_list_.end(); ++i) { + ApplicationSharedPtr application = *i; + uint32_t app_id = application->app_id(); + applications_ids.push_back(app_id); + } + applications_list_lock_.Release(); + + SendUpdateAppList(applications_ids); +} + +void ApplicationManagerImpl::OnTimerSendTTSGlobalProperties() { + std::vector<uint32_t> app_list; + { + sync_primitives::AutoLock lock(tts_global_properties_app_list_lock_); + std::map<uint32_t, TimevalStruct>::iterator it = + tts_global_properties_app_list_.begin(); + std::map<uint32_t, TimevalStruct>::iterator it_end = + tts_global_properties_app_list_.end(); + date_time::TimeCompare time_comp; + for (; it != it_end; ++it) { + time_comp = date_time::DateTime::compareTime( + date_time::DateTime::getCurrentTime(), it->second); + if (date_time::GREATER == time_comp || date_time::EQUAL == time_comp) { + app_list.push_back(it->first); + } + } + } + if (!app_list.empty()) { + for (uint32_t i = 0; i < app_list.size(); ++i) { + LOG4CXX_INFO(logger_, "Send TTS GlobalProperties to HMI with default helpPrompt"); + MessageHelper::SendTTSGlobalProperties(application(app_list[i]), true); + RemoveAppFromTTSGlobalPropertiesList(app_list[i]); + } + } +} + +void ApplicationManagerImpl::AddAppToTTSGlobalPropertiesList( + const uint32_t app_id) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::AddAppToTTSGlobalPropertiesList"); + uint16_t timeout = profile::Profile::instance()->tts_global_properties_timeout(); + TimevalStruct current_time = date_time::DateTime::getCurrentTime(); + current_time.tv_sec += timeout; + sync_primitives::AutoLock lock(tts_global_properties_app_list_lock_); + if (tts_global_properties_app_list_.end() == + tts_global_properties_app_list_.find(app_id)) { + tts_global_properties_app_list_[app_id] = current_time; + } + //if add first item need to start timer on one second + if (1 == tts_global_properties_app_list_.size()) { + LOG4CXX_INFO(logger_, "Start tts_global_properties_timer_"); + tts_global_properties_timer_.start(1); + } +} + +void ApplicationManagerImpl::RemoveAppFromTTSGlobalPropertiesList( + const uint32_t app_id) { + LOG4CXX_INFO(logger_, "ApplicationManagerImpl::RemoveAppFromTTSGlobalPropertiesList"); + sync_primitives::AutoLock lock(tts_global_properties_app_list_lock_); + std::map<uint32_t, TimevalStruct>::iterator it = + tts_global_properties_app_list_.find(app_id); + if (tts_global_properties_app_list_.end() != it) { + tts_global_properties_app_list_.erase(it); + if (!(tts_global_properties_app_list_.size())) { + LOG4CXX_INFO(logger_, "Stop tts_global_properties_timer_"); + //if container is empty need to stop timer + tts_global_properties_timer_.stop(); + } + } +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/command_impl.cc b/src/components/application_manager/src/commands/command_impl.cc new file mode 100644 index 0000000000..af666b22c4 --- /dev/null +++ b/src/components/application_manager/src/commands/command_impl.cc @@ -0,0 +1,80 @@ +/** + Copyright (c) 2014, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/command_impl.h" +#include "config_profile/profile.h" + +namespace application_manager { +namespace commands { + +CREATE_LOGGERPTR_LOCAL(CommandImpl::logger_, "Commands") + +const int32_t CommandImpl::hmi_protocol_type_ = 1; +const int32_t CommandImpl::mobile_protocol_type_ = 0; +const int32_t CommandImpl::protocol_version_ = 3; + +CommandImpl::CommandImpl(const MessageSharedPtr& message) + : message_(message), + default_timeout_(profile::Profile::instance()->default_timeout()) { +} + +CommandImpl::~CommandImpl() { + CleanUp(); +} + +bool CommandImpl::CheckPermissions(){ + return true; +} + +bool CommandImpl::Init() { + return true; +} + +bool CommandImpl::CleanUp() { + return true; +} + +void CommandImpl::Run() { +} + +uint32_t CommandImpl::default_timeout() const { + return default_timeout_; +} + + +uint32_t CommandImpl::correlation_id() const { + return (*message_)[strings::params][strings::correlation_id].asUInt(); +} + + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/command_notification_impl.cc b/src/components/application_manager/src/commands/command_notification_impl.cc new file mode 100644 index 0000000000..c99f2d9086 --- /dev/null +++ b/src/components/application_manager/src/commands/command_notification_impl.cc @@ -0,0 +1,74 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/command_notification_impl.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +CommandNotificationImpl::CommandNotificationImpl( + const MessageSharedPtr& message) + : CommandImpl(message) { +} + +CommandNotificationImpl::~CommandNotificationImpl() { +} + +bool CommandNotificationImpl::Init() { + return true; +} + +bool CommandNotificationImpl::CleanUp() { + return true; +} + +void CommandNotificationImpl::Run() { +} + +void CommandNotificationImpl::SendNotification() { + (*message_)[strings::params][strings::protocol_type] = mobile_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + (*message_)[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + + LOG4CXX_INFO(logger_, "SendNotification"); + MessageHelper::PrintSmartObject(*message_); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/command_request_impl.cc b/src/components/application_manager/src/commands/command_request_impl.cc new file mode 100644 index 0000000000..5f8757754f --- /dev/null +++ b/src/components/application_manager/src/commands/command_request_impl.cc @@ -0,0 +1,548 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <algorithm> +#include <string> +#include "application_manager/commands/command_request_impl.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "smart_objects/smart_object.h" + +namespace application_manager { + +namespace commands { + +struct DisallowedParamsInserter { + DisallowedParamsInserter(smart_objects::SmartObject& response, + mobile_apis::VehicleDataResultCode::eType code) + : response_(response), + code_(code) { + } + + bool operator()(const std::string& param) { + const VehicleData& vehicle_data = + application_manager::MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.find(param); + if (vehicle_data.end() != it) { + smart_objects::SmartObject* disallowed_param = + new smart_objects::SmartObject(smart_objects::SmartType_Map); + (*disallowed_param)[strings::data_type] = (*it).second; + (*disallowed_param)[strings::result_code] = code_; + response_[strings::msg_params][param.c_str()] = *disallowed_param; + return true; + } + return false; + } +private: + smart_objects::SmartObject& response_; + mobile_apis::VehicleDataResultCode::eType code_; +}; + +CommandRequestImpl::CommandRequestImpl(const MessageSharedPtr& message) + : CommandImpl(message), + current_state_(kAwaitingHMIResponse) { +} + +CommandRequestImpl::~CommandRequestImpl() { +} + +bool CommandRequestImpl::Init() { + return true; +} + +bool CommandRequestImpl::CheckPermissions() { + return CheckAllowedParameters(); +} + +bool CommandRequestImpl::CleanUp() { + return true; +} + +void CommandRequestImpl::Run() { +} + +void CommandRequestImpl::onTimeOut() { + LOG4CXX_INFO(logger_, "CommandRequestImpl::onTimeOut"); + + unsubscribe_from_all_events(); + { + sync_primitives::AutoLock auto_lock(state_lock_); + if (kCompleted == current_state_) { + // don't send timeout if request completed + return; + } + + current_state_ = kTimedOut; + } + + smart_objects::SmartObject* response = + MessageHelper::CreateNegativeResponse(connection_key(), function_id(), + correlation_id(), mobile_api::Result::GENERIC_ERROR); + + ApplicationManagerImpl::instance()->ManageMobileCommand(response); +} + +void CommandRequestImpl::on_event(const event_engine::Event& event) { +} + +void CommandRequestImpl::SendResponse( + const bool success, const mobile_apis::Result::eType& result_code, + const char* info, const NsSmart::SmartObject* response_params) { + + { + sync_primitives::AutoLock auto_lock(state_lock_); + if (kTimedOut == current_state_) { + // don't send response if request timeout expired + return; + } + + current_state_ = kCompleted; + } + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + new NsSmartDeviceLink::NsSmartObjects::SmartObject; + if (!result) { + LOG4CXX_ERROR(logger_, "Memory allocation failed."); + return; + } + NsSmartDeviceLink::NsSmartObjects::SmartObject& response = *result; + + response[strings::params][strings::message_type] = MessageType::kResponse; + response[strings::params][strings::correlation_id] = correlation_id(); + response[strings::params][strings::protocol_type] = + CommandImpl::mobile_protocol_type_; + response[strings::params][strings::protocol_version] = + CommandImpl::protocol_version_; + response[strings::params][strings::connection_key] = connection_key(); + response[strings::params][strings::function_id] = function_id(); + + if (response_params) { + response[strings::msg_params] = *response_params; + } + + if (info) { + response[strings::msg_params][strings::info] = std::string(info); + } + + // Add disallowed parameters and info from request back to response with appropriate + // reasons (VehicleData result codes) + if (result_code != mobile_apis::Result::APPLICATION_NOT_REGISTERED) { + const mobile_apis::FunctionID::eType& id = + static_cast<mobile_apis::FunctionID::eType>(function_id()); + if ((id == mobile_apis::FunctionID::SubscribeVehicleDataID) || + (id == mobile_apis::FunctionID::UnsubscribeVehicleDataID)) { + AddDisallowedParameters(response); + AddDisallowedParametersToInfo(response); + } else if (id == mobile_apis::FunctionID::GetVehicleDataID) { + AddDisallowedParametersToInfo(response); + } + } + + response[strings::msg_params][strings::success] = success; + response[strings::msg_params][strings::result_code] = result_code; + + ApplicationManagerImpl::instance()->ManageMobileCommand(result); +} + +bool CommandRequestImpl::CheckSyntax(std::string str, bool allow_empty_line) { + if (std::string::npos != str.find_first_of("\t\n")) { + LOG4CXX_ERROR(logger_, "CheckSyntax failed! :" << str); + return false; + } + if (std::string::npos != str.find("\\n") || + std::string::npos != str.find("\\t")) { + LOG4CXX_ERROR(logger_, "CheckSyntax failed! :" << str); + return false; + } + if (!allow_empty_line) { + if ((std::string::npos == str.find_first_not_of(' '))) { + return false; + } + } + return true; +} + +void CommandRequestImpl::SendHMIRequest( + const hmi_apis::FunctionID::eType& function_id, + const NsSmart::SmartObject* msg_params, bool use_events) { + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + new NsSmartDeviceLink::NsSmartObjects::SmartObject; + if (!result) { + LOG4CXX_ERROR(logger_, "Memory allocation failed."); + return; + } + + const uint32_t hmi_correlation_id = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + if (use_events) { + LOG4CXX_WARN(logger_, "subscribe_on_event " << function_id << " " << hmi_correlation_id); + subscribe_on_event(function_id, hmi_correlation_id); + } + + NsSmartDeviceLink::NsSmartObjects::SmartObject& request = *result; + request[strings::params][strings::message_type] = MessageType::kRequest; + request[strings::params][strings::function_id] = function_id; + request[strings::params][strings::correlation_id] = hmi_correlation_id; + request[strings::params][strings::protocol_version] = + CommandImpl::protocol_version_; + request[strings::params][strings::protocol_type] = + CommandImpl::hmi_protocol_type_; + + if (msg_params) { + request[strings::msg_params] = *msg_params; + } + + if (!ApplicationManagerImpl::instance()->ManageHMICommand(result)) { + LOG4CXX_ERROR(logger_, "Unable to send request"); + SendResponse(false, mobile_apis::Result::OUT_OF_MEMORY); + } +} + +void CommandRequestImpl::CreateHMINotification( + const hmi_apis::FunctionID::eType& function_id, + const NsSmart::SmartObject& msg_params) const { + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + new NsSmartDeviceLink::NsSmartObjects::SmartObject; + if (!result) { + LOG4CXX_ERROR(logger_, "Memory allocation failed."); + return; + } + NsSmartDeviceLink::NsSmartObjects::SmartObject& notify = *result; + + notify[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + notify[strings::params][strings::function_id] = function_id; + notify[strings::msg_params] = msg_params; + + if (!ApplicationManagerImpl::instance()->ManageHMICommand(result)) { + LOG4CXX_ERROR(logger_, "Unable to send HMI notification"); + } +} + +mobile_apis::Result::eType CommandRequestImpl::GetMobileResultCode( + const hmi_apis::Common_Result::eType& hmi_code) const { + + mobile_apis::Result::eType mobile_result = mobile_apis::Result::GENERIC_ERROR; + switch (hmi_code) { + case hmi_apis::Common_Result::SUCCESS: { + mobile_result = mobile_apis::Result::SUCCESS; + break; + } + case hmi_apis::Common_Result::UNSUPPORTED_REQUEST: { + mobile_result = mobile_apis::Result::UNSUPPORTED_REQUEST; + break; + } + case hmi_apis::Common_Result::UNSUPPORTED_RESOURCE: { + mobile_result = mobile_apis::Result::UNSUPPORTED_RESOURCE; + break; + } + case hmi_apis::Common_Result::DISALLOWED: { + mobile_result = mobile_apis::Result::DISALLOWED; + break; + } + case hmi_apis::Common_Result::REJECTED: { + mobile_result = mobile_apis::Result::REJECTED; + break; + } + case hmi_apis::Common_Result::ABORTED: { + mobile_result = mobile_apis::Result::ABORTED; + break; + } + case hmi_apis::Common_Result::IGNORED: { + mobile_result = mobile_apis::Result::IGNORED; + break; + } + case hmi_apis::Common_Result::RETRY: { + mobile_result = mobile_apis::Result::RETRY; + break; + } + case hmi_apis::Common_Result::IN_USE: { + mobile_result = mobile_apis::Result::IN_USE; + break; + } + case hmi_apis::Common_Result::DATA_NOT_AVAILABLE: { + mobile_result = mobile_apis::Result::VEHICLE_DATA_NOT_AVAILABLE; + break; + } + case hmi_apis::Common_Result::TIMED_OUT: { + mobile_result = mobile_apis::Result::TIMED_OUT; + break; + } + case hmi_apis::Common_Result::INVALID_DATA: { + mobile_result = mobile_apis::Result::INVALID_DATA; + break; + } + case hmi_apis::Common_Result::CHAR_LIMIT_EXCEEDED: { + mobile_result = mobile_apis::Result::CHAR_LIMIT_EXCEEDED; + break; + } + case hmi_apis::Common_Result::INVALID_ID: { + mobile_result = mobile_apis::Result::INVALID_ID; + break; + } + case hmi_apis::Common_Result::DUPLICATE_NAME: { + mobile_result = mobile_apis::Result::DUPLICATE_NAME; + break; + } + case hmi_apis::Common_Result::APPLICATION_NOT_REGISTERED: { + mobile_result = mobile_apis::Result::APPLICATION_NOT_REGISTERED; + break; + } + case hmi_apis::Common_Result::WRONG_LANGUAGE: { + mobile_result = mobile_apis::Result::WRONG_LANGUAGE; + break; + } + case hmi_apis::Common_Result::OUT_OF_MEMORY: { + mobile_result = mobile_apis::Result::OUT_OF_MEMORY; + break; + } + case hmi_apis::Common_Result::TOO_MANY_PENDING_REQUESTS: { + mobile_result = mobile_apis::Result::TOO_MANY_PENDING_REQUESTS; + break; + } + case hmi_apis::Common_Result::NO_APPS_REGISTERED: { + mobile_result = mobile_apis::Result::APPLICATION_NOT_REGISTERED; + break; + } + case hmi_apis::Common_Result::NO_DEVICES_CONNECTED: { + mobile_result = mobile_apis::Result::APPLICATION_NOT_REGISTERED; + break; + } + case hmi_apis::Common_Result::WARNINGS: { + mobile_result = mobile_apis::Result::WARNINGS; + break; + } + case hmi_apis::Common_Result::GENERIC_ERROR: { + mobile_result = mobile_apis::Result::GENERIC_ERROR; + break; + } + case hmi_apis::Common_Result::USER_DISALLOWED: { + mobile_result = mobile_apis::Result::USER_DISALLOWED; + break; + } + default: { + LOG4CXX_ERROR(logger_, "Unknown HMI result code " << hmi_code); + break; + } + } + + return mobile_result; +} + +bool CommandRequestImpl::CheckAllowedParameters() { + LOG4CXX_INFO(logger_, "CheckAllowedParameters"); + + // RegisterAppInterface should always be allowed + if (mobile_apis::FunctionID::RegisterAppInterfaceID == + static_cast<mobile_apis::FunctionID::eType>(function_id())) { + return true; + } + + typedef std::set<application_manager::ApplicationSharedPtr> ApplicationList; + ApplicationManagerImpl::ApplicationListAccessor accessor; + ApplicationList app_list = accessor.applications(); + ApplicationList::const_iterator it_app_list = app_list.begin(); + ApplicationList::const_iterator it_app_list_end = app_list.end(); + for (; it_app_list != it_app_list_end; ++it_app_list) { + if (connection_key() == (*it_app_list).get()->app_id()) { + + RPCParams params; + + const smart_objects::SmartObject& s_map = (*message_)[strings::msg_params]; + if (smart_objects::SmartType_Map == s_map.getType()) { + smart_objects::SmartMap::iterator iter = s_map.map_begin(); + smart_objects::SmartMap::iterator iter_end = s_map.map_end(); + + for (; iter != iter_end; ++iter) { + params.push_back(iter->first); + } + } + + CommandParametersPermissions params_permissions; + mobile_apis::Result::eType check_result = + application_manager::ApplicationManagerImpl::instance()-> + CheckPolicyPermissions( + (*it_app_list).get()->mobile_app_id()->asString(), + (*it_app_list).get()->hmi_level(), + static_cast<mobile_api::FunctionID::eType>(function_id()), + params, + ¶ms_permissions); + + // Check, if RPC is allowed by policy + if (mobile_apis::Result::SUCCESS != check_result) { + smart_objects::SmartObject* response = + MessageHelper::CreateBlockedByPoliciesResponse( + static_cast<mobile_api::FunctionID::eType>(function_id()), + check_result, correlation_id(), (*it_app_list)->app_id()); + + ApplicationManagerImpl::instance()->SendMessageToMobile(response); + return false; + } + + // If no parameters specified in policy table, no restriction will be + // applied for parameters + if (params_permissions.allowed_params.empty() && + params_permissions.disallowed_params.empty() && + params_permissions.undefined_params.empty()) { + return true; + } + + RemoveDisallowedParameters(params_permissions); + } + } + return true; +} + +void CommandRequestImpl::RemoveDisallowedParameters( + const CommandParametersPermissions& params_permissions) { + LOG4CXX_INFO(logger_, "RemoveDisallowedParameters"); + + smart_objects::SmartObject& params = (*message_)[strings::msg_params]; + + // Remove from request all disallowed parameters + std::vector<std::string>::const_iterator it_disallowed = + params_permissions.disallowed_params.begin(); + std::vector<std::string>::const_iterator it_disallowed_end = + params_permissions.disallowed_params.end(); + for (;it_disallowed != it_disallowed_end; ++it_disallowed) { + if (params.keyExists(*it_disallowed)) { + params.erase(*it_disallowed); + parameters_permissions_.disallowed_params.push_back( + *it_disallowed); + LOG4CXX_INFO(logger_, "Following parameter is disallowed by user: " + << *it_disallowed); + } + } + + // Remove from request all undefined yet parameters + std::vector<std::string>::const_iterator it_undefined = + params_permissions.undefined_params.begin(); + std::vector<std::string>::const_iterator it_undefined_end = + params_permissions.undefined_params.end(); + for (;it_undefined != it_undefined_end; ++it_undefined) { + if (params.keyExists(*it_undefined)) { + params.erase(*it_undefined); + parameters_permissions_.undefined_params.push_back( + *it_undefined); + LOG4CXX_INFO(logger_, "Following parameter is disallowed by policy: " + << *it_undefined); + } + } + + // Remove from request all parameters missed in allowed + const VehicleData& vehicle_data = + application_manager::MessageHelper::vehicle_data(); + + VehicleData::const_iterator it_vehicle_data = vehicle_data.begin(); + VehicleData::const_iterator it_vehicle_data_end = vehicle_data.end(); + for (;it_vehicle_data != it_vehicle_data_end; ++it_vehicle_data) { + const std::string key = it_vehicle_data->first; + if (params.keyExists(key) && + params_permissions.allowed_params.end() == + std::find(params_permissions.allowed_params.begin(), + params_permissions.allowed_params.end(), + key)) { + params.erase(key); + parameters_permissions_.undefined_params.push_back(key); + LOG4CXX_INFO(logger_, + "Following parameter is not found among allowed parameters '" + << key + << "' and will be treated as disallowed."); + } + } +} + +void CommandRequestImpl::AddDissalowedParameterToInfoString( + std::string& info, const std::string& param) const { + // prepare disallowed params enumeration for response info string + if (info.empty()) { + info = "\'" + param + "\'"; + } else { + info = info + "," + " " + "\'" + param + "\'"; + } +} + +void CommandRequestImpl::AddDisallowedParametersToInfo( + smart_objects::SmartObject& response) const { + std::string info; + + std::vector<std::string>::const_iterator it = + parameters_permissions_.disallowed_params.begin(); + for (; it != parameters_permissions_.disallowed_params.end(); ++it) { + AddDissalowedParameterToInfoString(info, (*it)); + } + + it = parameters_permissions_.undefined_params.begin(); + for (; it != parameters_permissions_.undefined_params.end(); ++it) { + AddDissalowedParameterToInfoString(info, (*it)); + } + + if (!info.empty()) { + info += " disallowed by policies."; + + if (!response[strings::msg_params][strings::info].asString().empty()) { + // If we already have info add info about disallowed params to it + response[strings::msg_params][strings::info] = + response[strings::msg_params][strings::info].asString() + " " + info; + } else { + response[strings::msg_params][strings::info] = info; + } + } +} + +void CommandRequestImpl::AddDisallowedParameters( + smart_objects::SmartObject& response) { + DisallowedParamsInserter disallowed_inserter( + response, + mobile_apis::VehicleDataResultCode::VDRC_USER_DISALLOWED); + std::for_each(parameters_permissions_.disallowed_params.begin(), + parameters_permissions_.disallowed_params.end(), + disallowed_inserter); + + DisallowedParamsInserter undefined_inserter( + response, + mobile_apis::VehicleDataResultCode::VDRC_DISALLOWED); + std::for_each(parameters_permissions_.undefined_params.begin(), + parameters_permissions_.undefined_params.end(), + undefined_inserter); +} + +bool CommandRequestImpl::HasDisallowedParams() const { + return ((!parameters_permissions_.disallowed_params.empty()) || + (!parameters_permissions_.undefined_params.empty())); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/command_response_impl.cc b/src/components/application_manager/src/commands/command_response_impl.cc new file mode 100644 index 0000000000..d7bd9133bf --- /dev/null +++ b/src/components/application_manager/src/commands/command_response_impl.cc @@ -0,0 +1,88 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/command_response_impl.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +CommandResponseImpl::CommandResponseImpl(const MessageSharedPtr& message) + : CommandImpl(message) { +} + +CommandResponseImpl::~CommandResponseImpl() { +} + +bool CommandResponseImpl::Init() { + return true; +} + +bool CommandResponseImpl::CleanUp() { + return true; +} + +void CommandResponseImpl::Run() { +} + +void CommandResponseImpl::SendResponse( + bool success, const mobile_apis::Result::eType& result_code, bool final_message) { + LOG4CXX_INFO(logger_, "Trying to send response"); + + (*message_)[strings::params][strings::protocol_type] = mobile_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + (*message_)[strings::msg_params][strings::success] = success; + + if (!(*message_)[strings::msg_params].keyExists(strings::result_code)) { + if (mobile_apis::Result::INVALID_ENUM != result_code) { + (*message_)[strings::msg_params][strings::result_code] = result_code; + } else if ((*message_)[strings::params].keyExists(hmi_response::code)) { + (*message_)[strings::msg_params][strings::result_code] = + (*message_)[strings::params][hmi_response::code]; + } else { + if (success) { + (*message_)[strings::msg_params][strings::result_code] = + mobile_apis::Result::SUCCESS; + } else { + (*message_)[strings::msg_params][strings::result_code] = + mobile_apis::Result::INVALID_ENUM; + } + } + } + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_, final_message); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/activate_app_request.cc b/src/components/application_manager/src/commands/hmi/activate_app_request.cc new file mode 100644 index 0000000000..a1b17f5229 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/activate_app_request.cc @@ -0,0 +1,101 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/activate_app_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + + namespace commands { + + ActivateAppRequest::ActivateAppRequest( + const MessageSharedPtr& message): RequestToHMI(message) { + } + + + ActivateAppRequest::~ActivateAppRequest() { + LOG4CXX_TRACE(logger_, "~ActivateAppRequest"); + } + + void ActivateAppRequest::Run() { + LOG4CXX_TRACE(logger_, "enter " << correlation_id()); + uint32_t app_id = RequestToHMI::application_id(); + ApplicationManagerImpl::instance()->set_application_id(correlation_id(), app_id); +#ifdef ENABLE_LOG + mobile_apis::HMILevel::eType requested_hmi_level = static_cast<mobile_apis::HMILevel::eType>( + (*message_)[strings::msg_params][strings::activate_app_hmi_level].asInt()); + LOG4CXX_TRACE(logger_, "requested_hmi_level = " << requested_hmi_level); +#endif + SendRequest(); + subscribe_on_event(hmi_apis::FunctionID::BasicCommunication_ActivateApp, + correlation_id()); + LOG4CXX_TRACE(logger_, "exit"); + } + + + void ActivateAppRequest::on_event(const event_engine::Event& event) { + LOG4CXX_TRACE_ENTER(logger_); + const smart_objects::SmartObject* response = &(event.smart_object()); + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*response)[strings::params][hmi_response::code].asInt()); + if (hmi_apis::Common_Result::SUCCESS != code) { + LOG4CXX_ERROR(logger_, "Error ActivateApp result code " << code); + return; + } + int32_t correlation_id = RequestToHMI::correlation_id(); + // Mobile id is converted to HMI id for HMI requests + const uint32_t hmi_app_id = ApplicationManagerImpl::instance()-> + application_id(correlation_id); + mobile_apis::HMILevel::eType requested_hmi_level = static_cast<mobile_apis::HMILevel::eType>( + (*message_)[strings::msg_params][strings::activate_app_hmi_level].asInt()); + if (0 == hmi_app_id) { + LOG4CXX_ERROR(logger_, "Error hmi_app_id = "<< hmi_app_id); + return; + } + + ApplicationSharedPtr application = ApplicationManagerImpl::instance()-> + application_by_hmi_app(hmi_app_id); + if (!application.valid()) { + LOG4CXX_ERROR(logger_, "Application can't be activated."); + return; + } + if (mobile_apis::HMILevel::HMI_FULL == requested_hmi_level) { + ApplicationManagerImpl::instance()->ActivateApplication(application); + MessageHelper::SendHMIStatusNotification(*(application.get())); + } + } + } // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/activate_app_response.cc b/src/components/application_manager/src/commands/hmi/activate_app_response.cc new file mode 100644 index 0000000000..aba5886097 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/activate_app_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/activate_app_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +ActivateAppResponse::ActivateAppResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +ActivateAppResponse::~ActivateAppResponse() { +} + +void ActivateAppResponse::Run() { + LOG4CXX_TRACE(logger_, "enter"); + event_engine::Event event(hmi_apis::FunctionID::BasicCommunication_ActivateApp); + event.set_smart_object(*message_); + event.raise(); + LOG4CXX_TRACE(logger_, "exit"); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc b/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc new file mode 100644 index 0000000000..c11621045e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/add_statistics_info_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/add_statistics_info_notification.h" +#include "application_manager/policies/policy_handler.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +AddStatisticsInfoNotification::AddStatisticsInfoNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +AddStatisticsInfoNotification::~AddStatisticsInfoNotification() { +} + +void AddStatisticsInfoNotification::Run() { + LOG4CXX_INFO(logger_, "AddStatisticsInfoNotification::Run"); + + int type = (*message_)[strings::msg_params][hmi_notification::statistic_type] + .asInt(); + + policy::PolicyHandler::instance()->AddStatisticsInfo(type); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/allow_all_apps_request.cc b/src/components/application_manager/src/commands/hmi/allow_all_apps_request.cc new file mode 100644 index 0000000000..6ac42c7a00 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/allow_all_apps_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/allow_all_apps_request.h" + +namespace application_manager { + +namespace commands { + +AllowAllAppsRequest::AllowAllAppsRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +AllowAllAppsRequest::~AllowAllAppsRequest() { +} + +void AllowAllAppsRequest::Run() { + LOG4CXX_INFO(logger_, "AllowAllAppsRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/allow_all_apps_response.cc b/src/components/application_manager/src/commands/hmi/allow_all_apps_response.cc new file mode 100644 index 0000000000..69c52a3269 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/allow_all_apps_response.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/allow_all_apps_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +AllowAllAppsResponse::AllowAllAppsResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +AllowAllAppsResponse::~AllowAllAppsResponse() { +} + +void AllowAllAppsResponse::Run() { + LOG4CXX_INFO(logger_, "AllowAllAppsResponse::Run"); + + ApplicationManagerImpl::instance()->set_all_apps_allowed( + (*message_)[strings::msg_params][hmi_response::allowed].asBool()); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/allow_app_request.cc b/src/components/application_manager/src/commands/hmi/allow_app_request.cc new file mode 100644 index 0000000000..302a8c6766 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/allow_app_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/allow_app_request.h" + +namespace application_manager { + +namespace commands { + +AllowAppRequest::AllowAppRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +AllowAppRequest::~AllowAppRequest() { +} + +void AllowAppRequest::Run() { + LOG4CXX_INFO(logger_, "AllowAppRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/allow_app_response.cc b/src/components/application_manager/src/commands/hmi/allow_app_response.cc new file mode 100644 index 0000000000..035e41438d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/allow_app_response.cc @@ -0,0 +1,65 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/allow_app_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +AllowAppResponse::AllowAppResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +AllowAppResponse::~AllowAppResponse() { +} + +void AllowAppResponse::Run() { + LOG4CXX_INFO(logger_, "AllowAppResponse::Run"); + + uint32_t connection_key = + (*message_)[strings::params][strings::connection_key].asInt(); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()-> + application(connection_key); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + app->set_app_allowed((*message_)[strings::msg_params][hmi_response::allowed].asBool()); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/basic_communication_system_request.cc b/src/components/application_manager/src/commands/hmi/basic_communication_system_request.cc new file mode 100644 index 0000000000..0d2bcca4f4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/basic_communication_system_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/basic_communication_system_request.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +BasicCommunicationSystemRequest::BasicCommunicationSystemRequest( + const MessageSharedPtr& message): RequestToHMI(message) { +} + +BasicCommunicationSystemRequest::~BasicCommunicationSystemRequest() { +} + +void BasicCommunicationSystemRequest::Run() { + LOG4CXX_INFO(logger_, "BasicCommunicationSystemRequest::Run"); + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/basic_communication_system_response.cc b/src/components/application_manager/src/commands/hmi/basic_communication_system_response.cc new file mode 100644 index 0000000000..dd9f657adc --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/basic_communication_system_response.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/basic_communication_system_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +BasicCommunicationSystemResponse::BasicCommunicationSystemResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +BasicCommunicationSystemResponse::~BasicCommunicationSystemResponse() { +} + +void BasicCommunicationSystemResponse::Run() { + LOG4CXX_INFO(logger_, "BasicCommunicationSystemResponse::Run"); + event_engine::Event event(hmi_apis::FunctionID::BasicCommunication_SystemRequest); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/button_get_capabilities_request.cc b/src/components/application_manager/src/commands/hmi/button_get_capabilities_request.cc new file mode 100644 index 0000000000..e00b3fdc5a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/button_get_capabilities_request.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/button_get_capabilities_request.h" +#include "utils/logger.h" + +namespace application_manager { + +namespace commands { + +ButtonGetCapabilitiesRequest::ButtonGetCapabilitiesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +ButtonGetCapabilitiesRequest::~ButtonGetCapabilitiesRequest() { +} + +void ButtonGetCapabilitiesRequest::Run() { + LOG4CXX_INFO(logger_, "ButtonGetCapabilitiesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/button_get_capabilities_response.cc b/src/components/application_manager/src/commands/hmi/button_get_capabilities_response.cc new file mode 100644 index 0000000000..0b67234743 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/button_get_capabilities_response.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/button_get_capabilities_response.h" +#include "application_manager/application_manager_impl.h" +#include "utils/logger.h" + +namespace application_manager { + +namespace commands { + +ButtonGetCapabilitiesResponse::ButtonGetCapabilitiesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +ButtonGetCapabilitiesResponse::~ButtonGetCapabilitiesResponse() { +} + +void ButtonGetCapabilitiesResponse::Run() { + LOG4CXX_INFO(logger_, "ButtonGetCapabilitiesResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_button_capabilities( + (*message_)[strings::msg_params][hmi_response::capabilities]); + + hmi_capabilities.set_preset_bank_capabilities( + (*message_)[strings::msg_params][hmi_response::preset_bank_capabilities]); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/close_popup_request.cc b/src/components/application_manager/src/commands/hmi/close_popup_request.cc new file mode 100644 index 0000000000..3cc5818688 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/close_popup_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/close_popup_request.h" + +namespace application_manager { + +namespace commands { + +ClosePopupRequest::ClosePopupRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +ClosePopupRequest::~ClosePopupRequest() { +} + +void ClosePopupRequest::Run() { + LOG4CXX_INFO(logger_, "ClosePopupRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/close_popup_response.cc b/src/components/application_manager/src/commands/hmi/close_popup_response.cc new file mode 100644 index 0000000000..fa98be5e02 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/close_popup_response.cc @@ -0,0 +1,53 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/close_popup_response.h" + +namespace application_manager { + +namespace commands { + +ClosePopupResponse::ClosePopupResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +ClosePopupResponse::~ClosePopupResponse() { +} + +void ClosePopupResponse::Run() { + LOG4CXX_INFO(logger_, "ClosePopupResponse::Run"); + + // TODO(VS): Process response from HMI +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/get_system_info_request.cc b/src/components/application_manager/src/commands/hmi/get_system_info_request.cc new file mode 100644 index 0000000000..53a084d23e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/get_system_info_request.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/get_system_info_request.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +GetSystemInfoRequest::GetSystemInfoRequest( + const MessageSharedPtr& message): RequestToHMI(message) { +} + +GetSystemInfoRequest::~GetSystemInfoRequest() { +} + +void GetSystemInfoRequest::Run() { + LOG4CXX_INFO(logger_, "GetSystemInfoRequest::Run"); + uint32_t correlation_id = RequestToHMI::correlation_id(); + uint32_t app_id = RequestToHMI::application_id(); + ApplicationManagerImpl::instance()->set_application_id(correlation_id, app_id); + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/get_system_info_response.cc b/src/components/application_manager/src/commands/hmi/get_system_info_response.cc new file mode 100644 index 0000000000..090b04c3e3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/get_system_info_response.cc @@ -0,0 +1,73 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/get_system_info_response.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +GetSystemInfoResponse::GetSystemInfoResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +GetSystemInfoResponse::~GetSystemInfoResponse() { +} + +void GetSystemInfoResponse::Run() { + LOG4CXX_INFO(logger_, "GetSystemInfoResponse::Run"); + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*message_)[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS != code) { + LOG4CXX_WARN(logger_, "GetSystemError returns an error code " << code); + return; + } + const std::string ccpu_version = + (*message_)[strings::msg_params]["ccpu_version"].asString(); + const std::string wers_country_code = + (*message_)[strings::msg_params]["wersCountryCode"].asString(); + uint32_t lang_code = (*message_)[strings::msg_params]["language"].asUInt(); + const std::string language = + application_manager::MessageHelper::CommonLanguageToString( + static_cast<hmi_apis::Common_Language::eType>(lang_code)); + + policy::PolicyHandler::instance()->OnGetSystemInfo(ccpu_version, + wers_country_code, + language); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/get_urls.cc b/src/components/application_manager/src/commands/hmi/get_urls.cc new file mode 100644 index 0000000000..b3d0f60610 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/get_urls.cc @@ -0,0 +1,75 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/get_urls.h" +#include "application_manager/message.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { +namespace commands { + +GetUrls::GetUrls(const MessageSharedPtr& message) + : RequestFromHMI(message) { +} + +GetUrls::~GetUrls() { +} + +void GetUrls::Run() { + LOG4CXX_INFO(logger_, "GetUrls::Run"); + smart_objects::SmartObject& object = *message_; + object[strings::params][strings::message_type] = MessageType::kResponse; + if (policy::PolicyHandler::instance()->PolicyEnabled()) { + policy::EndpointUrls endpoints = + policy::PolicyHandler::instance()->GetUpdateUrls( + object[strings::msg_params][hmi_request::service].asInt()); + object[strings::msg_params].erase(hmi_request::service); + object[strings::msg_params][hmi_response::urls] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + for (size_t i = 0; i < endpoints.size(); ++i) { + std::string url = endpoints[i].url.empty() ? "" : endpoints[i].url[0]; + object[strings::msg_params][hmi_response::urls][i][strings::url] = url; + if (policy::kDefaultId != endpoints[i].app_id) { + object[strings::msg_params][hmi_response::urls][i][hmi_response::policy_app_id] = + endpoints[i].app_id; + } + } + object[strings::params][hmi_response::code] = hmi_apis::Common_Result::SUCCESS; + } else { + object[strings::params][hmi_response::code] = hmi_apis::Common_Result::DATA_NOT_AVAILABLE; + } + ApplicationManagerImpl::instance()->ManageHMICommand(message_); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/get_urls_response.cc b/src/components/application_manager/src/commands/hmi/get_urls_response.cc new file mode 100644 index 0000000000..f8086affe3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/get_urls_response.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/get_urls_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { +namespace commands { + +GetUrlsResponse::GetUrlsResponse( + const MessageSharedPtr& message): ResponseToHMI(message) { +} + +GetUrlsResponse::~GetUrlsResponse() { +} + +void GetUrlsResponse::Run() { + LOG4CXX_INFO(logger_, "GetUrlsResponse::Run"); + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/mixing_audio_supported_request.cc b/src/components/application_manager/src/commands/hmi/mixing_audio_supported_request.cc new file mode 100644 index 0000000000..9ab4bf5dbb --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/mixing_audio_supported_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/mixing_audio_supported_request.h" + +namespace application_manager { + +namespace commands { + +MixingAudioSupportedRequest::MixingAudioSupportedRequest( + const MessageSharedPtr& message) : RequestToHMI(message) { +} + +MixingAudioSupportedRequest::~MixingAudioSupportedRequest() { +} + +void MixingAudioSupportedRequest::Run() { + LOG4CXX_INFO(logger_, "MixingAudioSupportedRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/mixing_audio_supported_response.cc b/src/components/application_manager/src/commands/hmi/mixing_audio_supported_response.cc new file mode 100644 index 0000000000..4a4fc276de --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/mixing_audio_supported_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/mixing_audio_supported_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +MixingAudioSupportedResponse::MixingAudioSupportedResponse( + const MessageSharedPtr& message) : ResponseFromHMI(message) { +} + +MixingAudioSupportedResponse::~MixingAudioSupportedResponse() { +} + +void MixingAudioSupportedResponse::Run() { + LOG4CXX_INFO(logger_, "MixingAudioSupportedResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + hmi_capabilities.set_attenuated_supported((*message_) + [strings::msg_params][hmi_response::attenuated_supported].asBool()); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_alert_maneuver_request.cc b/src/components/application_manager/src/commands/hmi/navi_alert_maneuver_request.cc new file mode 100644 index 0000000000..7128231b11 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_alert_maneuver_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_alert_maneuver_request.h" + +namespace application_manager { + +namespace commands { + +NaviAlertManeuverRequest::NaviAlertManeuverRequest( + const MessageSharedPtr& message) : RequestToHMI(message) { +} + +NaviAlertManeuverRequest::~NaviAlertManeuverRequest() { +} + +void NaviAlertManeuverRequest::Run() { + LOG4CXX_INFO(logger_, "NaviAlertManeuverRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/navi_alert_maneuver_response.cc b/src/components/application_manager/src/commands/hmi/navi_alert_maneuver_response.cc new file mode 100644 index 0000000000..823c96211e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_alert_maneuver_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_alert_maneuver_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +NaviAlertManeuverResponse::NaviAlertManeuverResponse( + const MessageSharedPtr& message) : ResponseFromHMI(message) { +} + +NaviAlertManeuverResponse::~NaviAlertManeuverResponse() { +} + +void NaviAlertManeuverResponse::Run() { + LOG4CXX_INFO(logger_, "NaviAlertManeuverResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::Navigation_AlertManeuver); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_audio_start_stream_request.cc b/src/components/application_manager/src/commands/hmi/navi_audio_start_stream_request.cc new file mode 100644 index 0000000000..3c7a7d3ab5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_audio_start_stream_request.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_audio_start_stream_request.h" + +namespace application_manager { + +namespace commands { + +AudioStartStreamRequest::AudioStartStreamRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +AudioStartStreamRequest::~AudioStartStreamRequest() { +} + +void AudioStartStreamRequest::Run() { + LOG4CXX_INFO(logger_, "AudioStartStreamRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/navi_audio_start_stream_response.cc b/src/components/application_manager/src/commands/hmi/navi_audio_start_stream_response.cc new file mode 100644 index 0000000000..e4cc8f4cc6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_audio_start_stream_response.cc @@ -0,0 +1,72 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_audio_start_stream_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +AudioStartStreamResponse::AudioStartStreamResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +AudioStartStreamResponse::~AudioStartStreamResponse() { +} + +void AudioStartStreamResponse::Run() { + LOG4CXX_INFO(logger_, "AudioStartStreamResponse::Run"); + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->active_application(); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "NaviStartStreamResponse no active app!"); + return; + } + + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*message_)[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS == code) { + LOG4CXX_INFO(logger_, "AudioStartStreamResponse SUCCESS"); + app->set_hmi_supports_navi_audio_streaming(true); + } else { + LOG4CXX_INFO(logger_, "AudioStartStreamResponse NOT SUCCESS"); + app->set_hmi_supports_navi_audio_streaming(false); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_audio_stop_stream_request.cc b/src/components/application_manager/src/commands/hmi/navi_audio_stop_stream_request.cc new file mode 100644 index 0000000000..4052769d53 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_audio_stop_stream_request.cc @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_audio_stop_stream_request.h" + +namespace application_manager { + +namespace commands { + +AudioStopStreamRequest::AudioStopStreamRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +AudioStopStreamRequest::~AudioStopStreamRequest() { +} + +void AudioStopStreamRequest::Run() { + LOG4CXX_INFO(logger_, "AudioStopStreamRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_audio_stop_stream_response.cc b/src/components/application_manager/src/commands/hmi/navi_audio_stop_stream_response.cc new file mode 100644 index 0000000000..81a6c62e8d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_audio_stop_stream_response.cc @@ -0,0 +1,52 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_audio_stop_stream_response.h" + +namespace application_manager { + +namespace commands { + +AudioStopStreamResponse::AudioStopStreamResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +AudioStopStreamResponse::~AudioStopStreamResponse() { +} + +void AudioStopStreamResponse::Run() { + LOG4CXX_INFO(logger_, "AudioStopStreamResponse::Run"); + +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_is_ready_request.cc b/src/components/application_manager/src/commands/hmi/navi_is_ready_request.cc new file mode 100644 index 0000000000..b7a1799427 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_is_ready_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_is_ready_request.h" + +namespace application_manager { + +namespace commands { + +NaviIsReadyRequest::NaviIsReadyRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +NaviIsReadyRequest::~NaviIsReadyRequest() { +} + +void NaviIsReadyRequest::Run() { + LOG4CXX_INFO(logger_, "NaviIsReadyRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/navi_is_ready_response.cc b/src/components/application_manager/src/commands/hmi/navi_is_ready_response.cc new file mode 100644 index 0000000000..8aef42b40d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_is_ready_response.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_is_ready_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +NaviIsReadyResponse::NaviIsReadyResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +NaviIsReadyResponse::~NaviIsReadyResponse() { +} + +void NaviIsReadyResponse::Run() { + LOG4CXX_INFO(logger_, "NaviIsReadyResponse::Run"); + smart_objects::SmartObject& object = *message_; + + bool is_available = false; + if (object[strings::msg_params].keyExists(strings::available)) { + is_available = object[strings::msg_params][strings::available].asBool(); + } + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_is_navi_cooperating(is_available); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_send_location_request.cc b/src/components/application_manager/src/commands/hmi/navi_send_location_request.cc new file mode 100644 index 0000000000..f396a24323 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_send_location_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_send_location_request.h" + +namespace application_manager { + +namespace commands { + +NaviSendLocationRequest::NaviSendLocationRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +NaviSendLocationRequest::~NaviSendLocationRequest() { +} + +void NaviSendLocationRequest::Run() { + LOG4CXX_INFO(logger_, "NaviSendLocationRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/navi_send_location_response.cc b/src/components/application_manager/src/commands/hmi/navi_send_location_response.cc new file mode 100644 index 0000000000..944ced170c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_send_location_response.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_send_location_response.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +NaviSendLocationResponse::NaviSendLocationResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +NaviSendLocationResponse::~NaviSendLocationResponse() { +} + +void NaviSendLocationResponse::Run() { + LOG4CXX_INFO(logger_, "NaviSendLocationResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::Navigation_SendLocation); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_show_constant_tbt_request.cc b/src/components/application_manager/src/commands/hmi/navi_show_constant_tbt_request.cc new file mode 100644 index 0000000000..9103e1f6c4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_show_constant_tbt_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_show_constant_tbt_request.h" + +namespace application_manager { + +namespace commands { + +NaviShowConstantTBTRequest::NaviShowConstantTBTRequest( + const MessageSharedPtr& message) : RequestToHMI(message) { +} + +NaviShowConstantTBTRequest::~NaviShowConstantTBTRequest() { +} + +void NaviShowConstantTBTRequest::Run() { + LOG4CXX_INFO(logger_, "NaviShowConstantTBTRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/navi_show_constant_tbt_response.cc b/src/components/application_manager/src/commands/hmi/navi_show_constant_tbt_response.cc new file mode 100644 index 0000000000..03c70dd81b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_show_constant_tbt_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_show_constant_tbt_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +NaviShowConstantTBTResponse::NaviShowConstantTBTResponse( + const MessageSharedPtr& message) : ResponseFromHMI(message) { +} + +NaviShowConstantTBTResponse::~NaviShowConstantTBTResponse() { +} + +void NaviShowConstantTBTResponse::Run() { + LOG4CXX_INFO(logger_, "NaviShowConstantTBTResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::Navigation_ShowConstantTBT); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_start_stream_request.cc b/src/components/application_manager/src/commands/hmi/navi_start_stream_request.cc new file mode 100644 index 0000000000..cb9dbd61e3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_start_stream_request.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_start_stream_request.h" + +namespace application_manager { + +namespace commands { + +NaviStartStreamRequest::NaviStartStreamRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +NaviStartStreamRequest::~NaviStartStreamRequest() { +} + +void NaviStartStreamRequest::Run() { + LOG4CXX_INFO(logger_, "NaviStartStreamRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/navi_start_stream_response.cc b/src/components/application_manager/src/commands/hmi/navi_start_stream_response.cc new file mode 100644 index 0000000000..79d51dcb66 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_start_stream_response.cc @@ -0,0 +1,73 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_start_stream_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +NaviStartStreamResponse::NaviStartStreamResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +NaviStartStreamResponse::~NaviStartStreamResponse() { +} + +void NaviStartStreamResponse::Run() { + LOG4CXX_INFO(logger_, "NaviStartStreamResponse::Run"); + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->active_application(); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "NaviStartStreamResponse no active app!"); + return; + } + + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*message_)[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS == code) { + LOG4CXX_INFO(logger_, "NaviStartStreamResponse SUCCESS"); + app->set_hmi_supports_navi_video_streaming(true); + } else { + LOG4CXX_INFO(logger_, "NaviStartStreamResponse NOT SUCCESS"); + app->set_hmi_supports_navi_video_streaming(false); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_stop_stream_request.cc b/src/components/application_manager/src/commands/hmi/navi_stop_stream_request.cc new file mode 100644 index 0000000000..2f1e14a122 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_stop_stream_request.cc @@ -0,0 +1,23 @@ +#include "application_manager/commands/hmi/navi_stop_stream_request.h" + +namespace application_manager { + +namespace commands { + +NaviStopStreamRequest::NaviStopStreamRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +NaviStopStreamRequest::~NaviStopStreamRequest() { +} + +void NaviStopStreamRequest::Run() { + LOG4CXX_INFO(logger_, "NaviStopStreamRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_stop_stream_response.cc b/src/components/application_manager/src/commands/hmi/navi_stop_stream_response.cc new file mode 100644 index 0000000000..c368940d5b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_stop_stream_response.cc @@ -0,0 +1,52 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_stop_stream_response.h" + +namespace application_manager { + +namespace commands { + +NaviStopStreamResponse::NaviStopStreamResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +NaviStopStreamResponse::~NaviStopStreamResponse() { +} + +void NaviStopStreamResponse::Run() { + LOG4CXX_INFO(logger_, "NaviStopStreamResponse::Run"); + +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/navi_update_turn_list_request.cc b/src/components/application_manager/src/commands/hmi/navi_update_turn_list_request.cc new file mode 100644 index 0000000000..d0df9ec867 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_update_turn_list_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_update_turn_list_request.h" + +namespace application_manager { + +namespace commands { + +NaviUpdateTurnListRequest::NaviUpdateTurnListRequest( + const MessageSharedPtr& message) : RequestToHMI(message) { +} + +NaviUpdateTurnListRequest::~NaviUpdateTurnListRequest() { +} + +void NaviUpdateTurnListRequest::Run() { + LOG4CXX_INFO(logger_, "NaviUpdateTurnListRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/navi_update_turn_list_response.cc b/src/components/application_manager/src/commands/hmi/navi_update_turn_list_response.cc new file mode 100644 index 0000000000..d93b67bb52 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/navi_update_turn_list_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/navi_update_turn_list_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +NaviUpdateTurnListResponse::NaviUpdateTurnListResponse( + const MessageSharedPtr& message) : ResponseFromHMI(message) { +} + +NaviUpdateTurnListResponse::~NaviUpdateTurnListResponse() { +} + +void NaviUpdateTurnListResponse::Run() { + LOG4CXX_INFO(logger_, "NaviUpdateTurnListResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::Navigation_UpdateTurnList); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/notification_from_hmi.cc b/src/components/application_manager/src/commands/hmi/notification_from_hmi.cc new file mode 100644 index 0000000000..2b7ec13c43 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/notification_from_hmi.cc @@ -0,0 +1,103 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/notification_from_hmi.h" +#include "application_manager/application_manager_impl.h" +#include "smart_objects/smart_object.h" + +namespace application_manager { + +namespace commands { + +NotificationFromHMI::NotificationFromHMI(const MessageSharedPtr& message) + : CommandImpl(message) { + + // Replace HMI app id with Mobile connection id + ApplicationManagerImpl::instance()->ReplaceHMIByMobileAppId(*(message.get())); +} + +NotificationFromHMI::~NotificationFromHMI() { +} + +bool NotificationFromHMI::Init() { + return true; +} + +bool NotificationFromHMI::CleanUp() { + return true; +} + +void NotificationFromHMI::Run() { +} + +void NotificationFromHMI::SendNotificationToMobile( + const MessageSharedPtr& message) { + ApplicationManagerImpl::instance()->ManageMobileCommand(message); +} + +void NotificationFromHMI::CreateHMIRequest( + const hmi_apis::FunctionID::eType& function_id, + const NsSmartObj::SmartObject& msg_params) const { + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + new NsSmartDeviceLink::NsSmartObjects::SmartObject; + if (!result) { + LOG4CXX_ERROR(logger_, "Memory allocation failed."); + return; + } + + // get hmi correlation id for chaining further request from this object + const uint32_t hmi_correlation_id_ = ApplicationManagerImpl::instance() + ->GetNextHMICorrelationID(); + + NsSmartDeviceLink::NsSmartObjects::SmartObject& request = *result; + request[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kRequest); + request[strings::params][strings::function_id] = + static_cast<int32_t>(function_id); + request[strings::params][strings::correlation_id] = hmi_correlation_id_; + request[strings::params][strings::protocol_version] = + CommandImpl::protocol_version_; + request[strings::params][strings::protocol_type] = + CommandImpl::hmi_protocol_type_; + + request[strings::msg_params] = msg_params; + + if (!ApplicationManagerImpl::instance()->ManageHMICommand(result)) { + LOG4CXX_ERROR(logger_, "Unable to send request"); + return; + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc b/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc new file mode 100644 index 0000000000..e4f8920ec9 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc @@ -0,0 +1,69 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/notification_to_hmi.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +NotificationToHMI::NotificationToHMI(const MessageSharedPtr& message) + : CommandImpl(message) { + + // Replace Mobile connection id with HMI app id + ApplicationManagerImpl::instance()->ReplaceMobileByHMIAppId(*(message.get())); +} + +NotificationToHMI::~NotificationToHMI() { +} + +bool NotificationToHMI::Init() { + return true; +} + +bool NotificationToHMI::CleanUp() { + return true; +} + +void NotificationToHMI::Run() { +} + +void NotificationToHMI::SendNotification() { + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc b/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc new file mode 100644 index 0000000000..020428d6c0 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_allow_sdl_functionality_notification.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_allow_sdl_functionality_notification.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +OnAllowSDLFunctionalityNotification::OnAllowSDLFunctionalityNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnAllowSDLFunctionalityNotification::~OnAllowSDLFunctionalityNotification() { +} + +void OnAllowSDLFunctionalityNotification::Run() { + LOG4CXX_INFO(logger_, "OnAllowSDLFunctionalityNotification::Run"); + uint32_t device_id = 0; + if ((*message_)[strings::msg_params].keyExists("device")) { + device_id = (*message_)[strings::msg_params]["device"]["id"].asUInt(); + } + policy::PolicyHandler::instance()->OnAllowSDLFunctionalityNotification( + (*message_)[strings::msg_params][hmi_response::allowed].asBool(), + device_id); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_app_activated_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_activated_notification.cc new file mode 100644 index 0000000000..8152244a9c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_app_activated_notification.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_app_activated_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +OnAppActivatedNotification::OnAppActivatedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnAppActivatedNotification::~OnAppActivatedNotification() { +} + +void OnAppActivatedNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppActivatedNotification::Run"); + uint32_t app_id = ((*message_)[strings::msg_params][strings::app_id]).asUInt(); + MessageHelper::SendActivateAppToHMI(app_id); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_app_deactivated_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_deactivated_notification.cc new file mode 100644 index 0000000000..152546b24b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_app_deactivated_notification.cc @@ -0,0 +1,140 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_app_deactivated_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "config_profile/profile.h" + +namespace application_manager { + +namespace commands { + +OnAppDeactivatedNotification::OnAppDeactivatedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnAppDeactivatedNotification::~OnAppDeactivatedNotification() { +} + +void OnAppDeactivatedNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppDeactivatedNotification::Run"); + uint32_t app_id = (*message_)[strings::msg_params][strings::app_id].asUInt(); + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(app_id); + if (!app.valid()) { + LOG4CXX_ERROR(logger_, "Application not found, id="<<app_id); + return; + } + + if (!(((hmi_apis::Common_DeactivateReason::AUDIO == + (*message_)[strings::msg_params][hmi_request::reason].asInt()) || + (hmi_apis::Common_DeactivateReason::PHONECALL == + (*message_)[strings::msg_params][hmi_request::reason].asInt())) && + (app->hmi_level() == mobile_api::HMILevel::eType::HMI_LIMITED))) { + app = ApplicationManagerImpl::instance()->active_application(); + if (!app.valid()) { + LOG4CXX_ERROR_EXT(logger_, "OnAppDeactivatedNotification no active app!"); + return; + } + if (app_id != app->app_id()) { + LOG4CXX_ERROR_EXT(logger_, "Wrong application id!"); + return; + } + } + + if (mobile_api::HMILevel::eType::HMI_NONE == app->hmi_level()) { + return; + } + + switch ((*message_)[strings::msg_params][hmi_request::reason].asInt()) { + case hmi_apis::Common_DeactivateReason::AUDIO: { + if (app->is_media_application()) { + if (profile::Profile::instance()->is_mixing_audio_supported() && + (ApplicationManagerImpl::instance()->vr_session_started() || + app->tts_speak_state())) { + app->set_audio_streaming_state(mobile_api::AudioStreamingState::ATTENUATED); + } else { + app->set_audio_streaming_state(mobile_api::AudioStreamingState::NOT_AUDIBLE); + } + } + // switch HMI level for all applications in FULL or LIMITED + ApplicationManagerImpl::ApplicationListAccessor accessor; + ApplicationManagerImpl::TAppList applications = + accessor.applications(); + ApplicationManagerImpl::TAppListIt it = + applications.begin(); + for (; applications.end() != it; ++it) { + ApplicationSharedPtr app = *it; + if (app.valid()) { + if (mobile_apis::HMILevel::eType::HMI_FULL == app->hmi_level() || + mobile_apis::HMILevel::eType::HMI_LIMITED == app->hmi_level()) { + app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND); + MessageHelper::SendHMIStatusNotification(*app); + } + } + } + break; + } + case hmi_apis::Common_DeactivateReason::PHONECALL: { + app->set_audio_streaming_state(mobile_api::AudioStreamingState::NOT_AUDIBLE); + app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND); + break; + } + case hmi_apis::Common_DeactivateReason::NAVIGATIONMAP: + case hmi_apis::Common_DeactivateReason::PHONEMENU: + case hmi_apis::Common_DeactivateReason::SYNCSETTINGS: + case hmi_apis::Common_DeactivateReason::GENERAL: { + if (app->is_media_application()) { + if (mobile_api::HMILevel::HMI_FULL == app->hmi_level()) { + app->set_hmi_level(mobile_api::HMILevel::HMI_LIMITED); + } + } else { + app->set_hmi_level(mobile_api::HMILevel::HMI_BACKGROUND); + } + break; + } + default: { + LOG4CXX_ERROR_EXT(logger_, "Unknown reason of app deactivation"); + return; + } + } + + MessageHelper::SendHMIStatusNotification(*app); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_app_permission_changed_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_permission_changed_notification.cc new file mode 100644 index 0000000000..26d580e83a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_app_permission_changed_notification.cc @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_app_permission_changed_notification.h" + +namespace application_manager { + +namespace commands { + +OnAppPermissionChangedNotification::OnAppPermissionChangedNotification( + const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnAppPermissionChangedNotification::~OnAppPermissionChangedNotification() { +} + +void OnAppPermissionChangedNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppPermissionChangedNotification::Run"); + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc new file mode 100644 index 0000000000..951a2ebdf1 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_app_permission_consent_notification.cc @@ -0,0 +1,92 @@ + +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_app_permission_consent_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +OnAppPermissionConsentNotification::OnAppPermissionConsentNotification(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnAppPermissionConsentNotification::~OnAppPermissionConsentNotification() { +} + +void OnAppPermissionConsentNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppPermissionConsentNotification::Run"); + smart_objects::SmartObject& msg_params = (*message_)[strings::msg_params]; + + uint32_t connection_key = 0; + + policy::PermissionConsent permission_consent; + + // If user defined group permissions for specific app + if (msg_params.keyExists(strings::app_id)) { + connection_key = msg_params[strings::app_id].asUInt(); + } + + if (msg_params.keyExists("consentedFunctions")) { + smart_objects::SmartArray* user_consent = + msg_params["consentedFunctions"].asArray(); + + smart_objects::SmartArray::const_iterator it = user_consent->begin(); + smart_objects::SmartArray::const_iterator it_end = user_consent->end(); + for (; it != it_end; ++it) { + policy::FunctionalGroupPermission permissions; + permissions.group_id = (*it)["id"].asInt(); + permissions.group_alias = (*it)["name"].asString(); + if ((*it).keyExists("allowed")) { + permissions.state = (*it)["allowed"].asBool() ? policy::kGroupAllowed : + policy::kGroupDisallowed; + } else { + permissions.state = policy::kGroupUndefined; + } + + permission_consent.group_permissions.push_back(permissions); + } + + permission_consent.consent_source = msg_params["source"].asString(); + + policy::PolicyHandler::instance()->OnAppPermissionConsent(connection_key, + permission_consent); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_app_registered_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_registered_notification.cc new file mode 100644 index 0000000000..26bc396db6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_app_registered_notification.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_app_registered_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnAppRegisteredNotification::OnAppRegisteredNotification( + const MessageSharedPtr& message) : NotificationToHMI(message) { +} + +OnAppRegisteredNotification::~OnAppRegisteredNotification() { +} + +void OnAppRegisteredNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppRegisteredNotification::Run"); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc new file mode 100644 index 0000000000..2bedcb0631 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_app_unregistered_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +OnAppUnregisteredNotification::OnAppUnregisteredNotification( + const MessageSharedPtr& message) : NotificationToHMI(message) { +} + +OnAppUnregisteredNotification::~OnAppUnregisteredNotification() { +} + +void OnAppUnregisteredNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppUnregisteredNotification::Run"); + + //sending event for delete VRCommand on PerformInteraction + event_engine::Event event(hmi_apis::FunctionID::BasicCommunication_OnAppUnregistered); + event.set_smart_object(*message_); + event.raise(); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_button_event_notification.cc b/src/components/application_manager/src/commands/hmi/on_button_event_notification.cc new file mode 100644 index 0000000000..23aceaa7d6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_button_event_notification.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_button_event_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "utils/logger.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnButtonEventNotification::OnButtonEventNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +void OnButtonEventNotification::Run() { + LOG4CXX_INFO(logger_, "OnButtonEventNotification::Run"); + + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::OnButtonEventID); + + SendNotificationToMobile(message_); +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_button_press_notification.cc b/src/components/application_manager/src/commands/hmi/on_button_press_notification.cc new file mode 100644 index 0000000000..83bcbd7efa --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_button_press_notification.cc @@ -0,0 +1,64 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_button_press_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "utils/logger.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnButtonPressNotification::OnButtonPressNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +void OnButtonPressNotification::Run() { + LOG4CXX_INFO(logger_, "OnButtonPressNotification::Run"); + event_engine::Event event(hmi_apis::FunctionID::Buttons_OnButtonPress); + event.set_smart_object(*message_); + event.raise(); + (*message_)[strings::params][strings::function_id] = + static_cast<int>(mobile_apis::FunctionID::eType::OnButtonPressID); + SendNotificationToMobile(message_); +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_device_chosen_notification.cc b/src/components/application_manager/src/commands/hmi/on_device_chosen_notification.cc new file mode 100644 index 0000000000..537c246f42 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_device_chosen_notification.cc @@ -0,0 +1,60 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_device_chosen_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnDeviceChosenNotification::OnDeviceChosenNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnDeviceChosenNotification::~OnDeviceChosenNotification() { +} + +void OnDeviceChosenNotification::Run() { + LOG4CXX_INFO(logger_, "OnDeviceChosenNotification::Run"); + + if ((*message_)[strings::msg_params].keyExists(strings::device_info)) { + ApplicationManagerImpl::instance()->ConnectToDevice( + (*message_)[strings::msg_params][strings::device_info][strings::id] + .asInt()); + } +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc b/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc new file mode 100644 index 0000000000..8af2571b55 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_device_state_changed_notification.cc @@ -0,0 +1,70 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_device_state_changed_notification.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/message_helper.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +OnDeviceStateChangedNotification::OnDeviceStateChangedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnDeviceStateChangedNotification::~OnDeviceStateChangedNotification() { +} + +void OnDeviceStateChangedNotification::Run() { + LOG4CXX_INFO(logger_, "OnDeviceStateChangedNotification::Run"); + + if ((*message_)[strings::msg_params]["deviceState"] + == hmi_apis::Common_DeviceState::UNPAIRED) { + std::string device_id = (*message_)[strings::msg_params]["deviceInternalId"] + .asString(); + if (device_id.empty()) { + if ((*message_)[strings::msg_params].keyExists("deviceId")) { + device_id = MessageHelper::GetDeviceMacAddressForHandle( + (*message_)[strings::msg_params]["deviceId"]["id"].asInt()); + } + } + policy::PolicyHandler::instance()->RemoveDevice(device_id); + } +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_driver_distraction_notification.cc b/src/components/application_manager/src/commands/hmi/on_driver_distraction_notification.cc new file mode 100644 index 0000000000..d5a8edc48d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_driver_distraction_notification.cc @@ -0,0 +1,98 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 <set> +#include "application_manager/commands/hmi/on_driver_distraction_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnDriverDistractionNotification::OnDriverDistractionNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnDriverDistractionNotification::~OnDriverDistractionNotification() { +} + +void OnDriverDistractionNotification::Run() { + LOG4CXX_INFO(logger_, "OnDriverDistractionNotification::Run"); + + const hmi_apis::Common_DriverDistractionState::eType state = + static_cast<hmi_apis::Common_DriverDistractionState::eType>( + (*message_)[strings::msg_params][hmi_notification::state] + .asInt()); + ApplicationManagerImpl::instance()->set_driver_distraction(state); + + MessageSharedPtr on_driver_distraction = + new smart_objects::SmartObject(); + + if (false == on_driver_distraction.valid()) { + LOG4CXX_ERROR_EXT(logger_, "NULL pointer"); + return; + } + + (*on_driver_distraction)[strings::params][strings::function_id] = + mobile_api::FunctionID::OnDriverDistractionID; + + (*on_driver_distraction)[strings::msg_params][mobile_notification::state] = + state; + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + + std::set<ApplicationSharedPtr>::const_iterator it = applications.begin(); + for (; applications.end() != it; ++it) { + ApplicationSharedPtr app = *it; + if (app.valid()) { + if (mobile_apis::HMILevel::eType::HMI_NONE != app->hmi_level()) { + (*on_driver_distraction)[strings::params] + [strings::connection_key] = app->app_id(); + SendNotificationToMobile(on_driver_distraction); + } + } + } +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_exit_all_applications_notification.cc b/src/components/application_manager/src/commands/hmi/on_exit_all_applications_notification.cc new file mode 100644 index 0000000000..3d027ff1c6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_exit_all_applications_notification.cc @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_exit_all_applications_notification.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" +#include "utils/signals.h" + +namespace application_manager { + +namespace commands { + +OnExitAllApplicationsNotification::OnExitAllApplicationsNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnExitAllApplicationsNotification::~OnExitAllApplicationsNotification() { +} + +void OnExitAllApplicationsNotification::Run() { + LOG4CXX_INFO(logger_, "OnExitAllApplicationsNotification::Run"); + + const hmi_apis::Common_ApplicationsCloseReason::eType reason = + static_cast<hmi_apis::Common_ApplicationsCloseReason::eType>( + (*message_)[strings::msg_params][hmi_request::reason].asInt()); + + mobile_api::AppInterfaceUnregisteredReason::eType mob_reason = + mobile_api::AppInterfaceUnregisteredReason::INVALID_ENUM; + + ApplicationManagerImpl* app_manager = ApplicationManagerImpl::instance(); + + switch (reason) { + case hmi_apis::Common_ApplicationsCloseReason::IGNITION_OFF: { + mob_reason = mobile_api::AppInterfaceUnregisteredReason::IGNITION_OFF; + break; + } + case hmi_apis::Common_ApplicationsCloseReason::MASTER_RESET: { + mob_reason = mobile_api::AppInterfaceUnregisteredReason::MASTER_RESET; + break; + } + case hmi_apis::Common_ApplicationsCloseReason::FACTORY_DEFAULTS: { + mob_reason = mobile_api::AppInterfaceUnregisteredReason::FACTORY_DEFAULTS; + break; + } + case hmi_apis::Common_ApplicationsCloseReason::SUSPEND: { + app_manager->HeadUnitSuspend(); + SendOnSDLPersistenceComplete(); + return; + } + default : { + LOG4CXX_ERROR(logger_, "Unknown Application close reason" << reason); + return; + } + } + + app_manager->SetUnregisterAllApplicationsReason(mob_reason); + + if (mobile_api::AppInterfaceUnregisteredReason::MASTER_RESET == mob_reason || + mobile_api::AppInterfaceUnregisteredReason::FACTORY_DEFAULTS == mob_reason) { + app_manager->HeadUnitReset(mob_reason); + } + + threads::Thread::InterruptMainThread(); +} + +void OnExitAllApplicationsNotification::SendOnSDLPersistenceComplete() { + LOG4CXX_INFO(logger_, "" + "OnExitAllApplicationsNotification::SendOnSDLPersistenceComplete"); + + smart_objects::SmartObject* message = + new smart_objects::SmartObject(smart_objects::SmartType_Map); + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_OnSDLPersistenceComplete; + (*message)[strings::params][strings::message_type] = MessageType::kNotification; + (*message)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_exit_application_notification.cc b/src/components/application_manager/src/commands/hmi/on_exit_application_notification.cc new file mode 100644 index 0000000000..f4aed61392 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_exit_application_notification.cc @@ -0,0 +1,81 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_exit_application_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +OnExitApplicationNotification::OnExitApplicationNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnExitApplicationNotification::~OnExitApplicationNotification() { +} + +void OnExitApplicationNotification::Run() { + LOG4CXX_INFO(logger_, "OnExitApplicationNotification::Run"); + + ApplicationManagerImpl* app_mgr = ApplicationManagerImpl::instance(); + ApplicationSharedPtr app_impl = app_mgr->application( + (*message_)[strings::msg_params][strings::app_id].asUInt()); + if (!(app_impl.valid())) { + LOG4CXX_ERROR(logger_, "Application does not exist"); + return; + } + hmi_apis::Common_ApplicationToNONEReason::eType reason; + reason = static_cast<hmi_apis::Common_ApplicationToNONEReason::eType> + ((*message_)[strings::msg_params][strings::reason].asInt()); + switch (reason) { + case hmi_apis::Common_ApplicationToNONEReason::USER_EXIT : { + break; + } + default : { + LOG4CXX_WARN(logger_, "Unhandled reason"); + break; + } + } + app_impl->set_hmi_level(mobile_apis::HMILevel::HMI_NONE); + app_impl->set_audio_streaming_state(mobile_apis::AudioStreamingState::NOT_AUDIBLE); + app_impl->set_system_context(mobile_api::SystemContext::SYSCTXT_MAIN); + MessageHelper::SendHMIStatusNotification(*app_impl); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_file_removed_notification.cc b/src/components/application_manager/src/commands/hmi/on_file_removed_notification.cc new file mode 100644 index 0000000000..f1a590ee04 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_file_removed_notification.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_file_removed_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnFileRemovedNotification::OnFileRemovedNotification( + const MessageSharedPtr& message) : NotificationToHMI(message) { +} + +OnFileRemovedNotification::~OnFileRemovedNotification() { +} + +void OnFileRemovedNotification::Run() { + LOG4CXX_INFO(logger_, "OnFileRemovedNotification::Run"); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_find_applications.cc b/src/components/application_manager/src/commands/hmi/on_find_applications.cc new file mode 100644 index 0000000000..bc32ab1cf0 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_find_applications.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_find_applications.h" + +namespace application_manager { + +namespace commands { + +OnFindApplications::OnFindApplications(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnFindApplications::~OnFindApplications() { +} + +void OnFindApplications::Run() { + LOG4CXX_INFO(logger_, "OnFindApplications::Run"); + + // TODO(PV): add UpdateAppsOnDevice to ApplicationManager +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc b/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc new file mode 100644 index 0000000000..523013734f --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ignition_cycle_over_notification.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ignition_cycle_over_notification.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +OnIgnitionCycleOverNotification::OnIgnitionCycleOverNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnIgnitionCycleOverNotification::~OnIgnitionCycleOverNotification() { +} + +void OnIgnitionCycleOverNotification::Run() { + LOG4CXX_INFO(logger_, "OnIgnitionCycleOverNotification::Run"); + policy::PolicyHandler::instance()->OnIgnitionCycleOver(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_navi_tbt_client_state_notification.cc b/src/components/application_manager/src/commands/hmi/on_navi_tbt_client_state_notification.cc new file mode 100644 index 0000000000..a68ae90796 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_navi_tbt_client_state_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_navi_tbt_client_state_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnNaviTBTClientStateNotification::OnNaviTBTClientStateNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnNaviTBTClientStateNotification::~OnNaviTBTClientStateNotification() { +} + +void OnNaviTBTClientStateNotification::Run() { + LOG4CXX_INFO(logger_, "OnNaviTBTClientStateNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::OnTBTClientStateID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_play_tone_notification.cc b/src/components/application_manager/src/commands/hmi/on_play_tone_notification.cc new file mode 100644 index 0000000000..e05b38d456 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_play_tone_notification.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_play_tone_notification.h" + +namespace application_manager { + +namespace commands { + +OnPlayToneNotification::OnPlayToneNotification(const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnPlayToneNotification::~OnPlayToneNotification() { +} + +void OnPlayToneNotification::Run() { + LOG4CXX_INFO(logger_, "OnPlayToneNotification::Run"); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_policy_update.cc b/src/components/application_manager/src/commands/hmi/on_policy_update.cc new file mode 100644 index 0000000000..b3f5803d44 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_policy_update.cc @@ -0,0 +1,52 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_policy_update.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { +namespace commands { + +OnPolicyUpdate::OnPolicyUpdate(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnPolicyUpdate::~OnPolicyUpdate() { +} + +void OnPolicyUpdate::Run() { + LOG4CXX_INFO(logger_, "OnPolicyUpdate::Run"); + policy::PolicyHandler::instance()->OnPTExchangeNeeded(); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_put_file_notification.cc b/src/components/application_manager/src/commands/hmi/on_put_file_notification.cc new file mode 100644 index 0000000000..2fecbec9c7 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_put_file_notification.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_put_file_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnPutFileNotification::OnPutFileNotification( + const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnPutFileNotification::~OnPutFileNotification() { +} + +void OnPutFileNotification::Run() { + LOG4CXX_INFO(logger_, "OnPutFileNotification::Run"); + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ready_notification.cc b/src/components/application_manager/src/commands/hmi/on_ready_notification.cc new file mode 100644 index 0000000000..783aa4af40 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ready_notification.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ready_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnReadyNotification::OnReadyNotification(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnReadyNotification::~OnReadyNotification() { +} + +void OnReadyNotification::Run() { + LOG4CXX_INFO(logger_, "OnReadyNotification::Run"); + + ApplicationManagerImpl::instance()->OnHMIStartedCooperation(); + event_engine::Event event(hmi_apis::FunctionID::BasicCommunication_OnReady); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc b/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc new file mode 100644 index 0000000000..1e517f35de --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_received_policy_update.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 <string> +#include "application_manager/commands/hmi/on_received_policy_update.h" +#include "application_manager/policies/policy_handler.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +OnReceivedPolicyUpdate::OnReceivedPolicyUpdate(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnReceivedPolicyUpdate::~OnReceivedPolicyUpdate() { +} + +void OnReceivedPolicyUpdate::Run() { + LOG4CXX_INFO(logger_, "OnReceivedPolicyUpdate::Run"); + const std::string& file_path = + (*message_)[strings::msg_params][hmi_notification::policyfile].asString(); + policy::BinaryMessage file_content; + if (!file_system::ReadBinaryFile(file_path, file_content)) { + LOG4CXX_ERROR(logger_, "Failed to read Update file."); + return; + } + policy::PolicyHandler::instance()->ReceiveMessageFromSDK(file_path, file_content); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_record_start_notification.cc b/src/components/application_manager/src/commands/hmi/on_record_start_notification.cc new file mode 100644 index 0000000000..e0dae8f045 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_record_start_notification.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_record_start_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnRecordStartdNotification::OnRecordStartdNotification( + const MessageSharedPtr& message) : NotificationToHMI(message) { +} + +OnRecordStartdNotification::~OnRecordStartdNotification() { +} + +void OnRecordStartdNotification::Run() { + LOG4CXX_INFO(logger_, "OnRecordStartdNotification::Run"); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_resume_audio_source_notification.cc b/src/components/application_manager/src/commands/hmi/on_resume_audio_source_notification.cc new file mode 100644 index 0000000000..70868b826f --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_resume_audio_source_notification.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_resume_audio_source_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnResumeAudioSourceNotification::OnResumeAudioSourceNotification( + const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnResumeAudioSourceNotification::~OnResumeAudioSourceNotification() { +} + +void OnResumeAudioSourceNotification::Run() { + LOG4CXX_INFO(logger_, "OnResumeAudioSourceNotification::Run"); + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_sdl_close_notification.cc b/src/components/application_manager/src/commands/hmi/on_sdl_close_notification.cc new file mode 100644 index 0000000000..70240b4bf6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_sdl_close_notification.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_sdl_close_notification.h" + +namespace application_manager { + +namespace commands { + +OnSDLCloseNotification::OnSDLCloseNotification( + const MessageSharedPtr& message) : NotificationToHMI(message) { +} + +OnSDLCloseNotification::~OnSDLCloseNotification() { +} + +void OnSDLCloseNotification::Run() { + LOG4CXX_INFO(logger_, "OnSdlCloseNotification::Run"); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_sdl_consent_needed_notification.cc b/src/components/application_manager/src/commands/hmi/on_sdl_consent_needed_notification.cc new file mode 100644 index 0000000000..1fda4986e4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_sdl_consent_needed_notification.cc @@ -0,0 +1,56 @@ + +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_sdl_consent_needed_notification.h" + +namespace application_manager { + +namespace commands { + +OnSDLConsentNeededNotification::OnSDLConsentNeededNotification( + const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnSDLConsentNeededNotification::~OnSDLConsentNeededNotification() { +} + +void OnSDLConsentNeededNotification::Run() { + LOG4CXX_INFO(logger_, "OnSDLConsentNeededNotification::Run"); + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_sdl_persistence_complete_notification.cc b/src/components/application_manager/src/commands/hmi/on_sdl_persistence_complete_notification.cc new file mode 100644 index 0000000000..d71413ef85 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_sdl_persistence_complete_notification.cc @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_sdl_persistence_complete_notification.h" + +namespace application_manager { + +namespace commands { + +OnSDLPersistenceCompleteNotification::OnSDLPersistenceCompleteNotification( + const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnSDLPersistenceCompleteNotification::~OnSDLPersistenceCompleteNotification() { +} + +void OnSDLPersistenceCompleteNotification::Run() { + LOG4CXX_INFO(logger_, "OnSDLpersistenceCompleteNotification::Run"); + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/on_start_device_discovery.cc b/src/components/application_manager/src/commands/hmi/on_start_device_discovery.cc new file mode 100644 index 0000000000..fc5ffed42c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_start_device_discovery.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_start_device_discovery.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnStartDeviceDiscovery::OnStartDeviceDiscovery(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnStartDeviceDiscovery::~OnStartDeviceDiscovery() { +} + +void OnStartDeviceDiscovery::Run() { + LOG4CXX_INFO(logger_, "OnStartDeviceDiscovery::Run"); + + ApplicationManagerImpl::instance()->StartDevicesDiscovery(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_status_update_notification.cc b/src/components/application_manager/src/commands/hmi/on_status_update_notification.cc new file mode 100644 index 0000000000..6e4e65987e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_status_update_notification.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_status_update_notification.h" + +namespace application_manager { + +namespace commands { + +OnStatusUpdateNotification::OnStatusUpdateNotification( + const MessageSharedPtr& message) + : NotificationToHMI(message) { +} + +OnStatusUpdateNotification::~OnStatusUpdateNotification() { +} + +void OnStatusUpdateNotification::Run() { + LOG4CXX_INFO(logger_, "OnGetStatusUpdateNotification::Run"); + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_system_context_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_context_notification.cc new file mode 100644 index 0000000000..5a5c12b907 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_system_context_notification.cc @@ -0,0 +1,87 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_system_context_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { +namespace commands { + +OnSystemContextNotification::OnSystemContextNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnSystemContextNotification::~OnSystemContextNotification() { +} + +void OnSystemContextNotification::Run() { + LOG4CXX_INFO(logger_, "OnSystemContextNotification::Run"); + + mobile_api::SystemContext::eType system_context = + static_cast<mobile_api::SystemContext::eType>( + (*message_)[strings::msg_params][hmi_notification::system_context].asInt()); + + ApplicationSharedPtr app; + + if ((mobile_api::SystemContext::SYSCTXT_VRSESSION == system_context) || + (mobile_api::SystemContext::SYSCTXT_MENU == system_context) || + (mobile_api::SystemContext::SYSCTXT_HMI_OBSCURED == system_context)) { + app = ApplicationManagerImpl::instance()->active_application(); + } else if ((mobile_api::SystemContext::SYSCTXT_ALERT == system_context) || + (mobile_api::SystemContext::SYSCTXT_MAIN == system_context)) { + if ((*message_)[strings::msg_params].keyExists(strings::app_id)) { + app = ApplicationManagerImpl::instance()-> + application((*message_)[strings::msg_params][strings::app_id].asUInt()); + } + } + + if (app.valid() && (system_context != app->system_context()) && + (system_context != mobile_api::SystemContext::INVALID_ENUM)) { + SendSystemContextNotification(app, system_context); + } else { + LOG4CXX_ERROR(logger_, "Ignored wrong SystemContext notification!"); + } +} + +void OnSystemContextNotification::SendSystemContextNotification(ApplicationSharedPtr app, + mobile_api::SystemContext::eType system_context) { + app->set_system_context(system_context); + MessageHelper::SendHMIStatusNotification(*app); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc new file mode 100644 index 0000000000..bac3d37359 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_system_error_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_system_error_notification.h" +#include "application_manager/policies/policy_handler.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +OnSystemErrorNotification::OnSystemErrorNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnSystemErrorNotification::~OnSystemErrorNotification() { +} + +void OnSystemErrorNotification::Run() { + LOG4CXX_INFO(logger_, "OnSystemErrorNotification::Run"); + + int code = (*message_)[strings::msg_params][hmi_notification::error] + .asInt(); + + policy::PolicyHandler::instance()->OnSystemError(code); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc new file mode 100644 index 0000000000..ec8460d581 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_system_info_changed_notification.cc @@ -0,0 +1,64 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_system_info_changed_notification.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +OnSystemInfoChangedNotification::OnSystemInfoChangedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnSystemInfoChangedNotification::~OnSystemInfoChangedNotification() { +} + +void OnSystemInfoChangedNotification::Run() { + LOG4CXX_INFO(logger_, "OnSystemInfoChangedNotification::Run"); + uint32_t lang_code = + (*message_)[strings::msg_params][strings::language].asUInt(); + const std::string language = + application_manager::MessageHelper::CommonLanguageToString( + static_cast<hmi_apis::Common_Language::eType>(lang_code)); + + policy::PolicyHandler::instance()->OnSystemInfoChanged(language); +} + +} // namespace commands + +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc new file mode 100644 index 0000000000..e3d0ea511d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_system_request_notification.cc @@ -0,0 +1,96 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/application_impl.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/commands/hmi/on_system_request_notification.h" +#include "application_manager/policies/policy_handler.h" +#include "interfaces/MOBILE_API.h" +#include "utils/macro.h" + +using policy::PolicyHandler; + +namespace application_manager { + +namespace commands { + +OnSystemRequestNotification::OnSystemRequestNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnSystemRequestNotification::~OnSystemRequestNotification() { +} + +void OnSystemRequestNotification::Run() { + LOG4CXX_INFO(logger_, "OnSystemRequestNotification::Run"); + + smart_objects::SmartObject& params = (*message_)[strings::params]; + smart_objects::SmartObject& msg_params = (*message_)[strings::msg_params]; + + params[strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnSystemRequestID); + + std::string app_id = msg_params[strings::app_id].asString(); + + if (strings::default_app_id == app_id) { + PolicyHandler* policy_handler = PolicyHandler::instance(); + uint32_t selected_app_id = policy_handler->GetAppIdForSending(); + if (0 == selected_app_id) { + LOG4CXX_WARN(logger_, + "Can't select application to forward OnSystemRequestNotification"); + return; + } + ApplicationManagerImpl* app_mgr = ApplicationManagerImpl::instance(); + ApplicationSharedPtr selected_app = app_mgr->application(selected_app_id); + if (!selected_app.valid()) { + LOG4CXX_ERROR(logger_, "PolicyHandler selected invalid app_id"); + return; + } + params[strings::connection_key] = selected_app_id; + } else { + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application_by_policy_id(app_id); + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Application with such id is not yet registered."); + return; + } + params[strings::connection_key] = app->app_id(); + } + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_tts_language_change_notification.cc b/src/components/application_manager/src/commands/hmi/on_tts_language_change_notification.cc new file mode 100644 index 0000000000..60c0dca10a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_tts_language_change_notification.cc @@ -0,0 +1,96 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_tts_language_change_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnTTSLanguageChangeNotification::OnTTSLanguageChangeNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnTTSLanguageChangeNotification::~OnTTSLanguageChangeNotification() { +} + +void OnTTSLanguageChangeNotification::Run() { + LOG4CXX_INFO(logger_, "OnTTSLanguageChangeNotification::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_active_tts_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][strings::language].asInt())); + + /* need to clarify, because unchanged VR + cause WRONG_LANGUAGE on Register */ + hmi_capabilities.set_active_vr_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][strings::language].asInt())); + + (*message_)[strings::msg_params][strings::hmi_display_language] = + hmi_capabilities.active_ui_language(); + + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID); + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + + std::set<ApplicationSharedPtr>::iterator it = applications.begin(); + for (;applications.end() != it; ++it) { + ApplicationSharedPtr app = (*it); + (*message_)[strings::params][strings::connection_key] = app->app_id(); + SendNotificationToMobile(message_); + + if (static_cast<int>(app->language()) + != (*message_)[strings::msg_params][strings::language].asInt()) { + MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + app->app_id(), + mobile_api::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE); + ApplicationManagerImpl::instance()->UnregisterApplication( + app->app_id(), mobile_apis::Result::SUCCESS, false); + } + } +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_tts_reset_timeout_notification.cc b/src/components/application_manager/src/commands/hmi/on_tts_reset_timeout_notification.cc new file mode 100644 index 0000000000..047a5d985d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_tts_reset_timeout_notification.cc @@ -0,0 +1,31 @@ +#include "application_manager/commands/hmi/on_tts_reset_timeout_notification.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnTTSResetTimeoutNotification::OnTTSResetTimeoutNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnTTSResetTimeoutNotification::~OnTTSResetTimeoutNotification() { +} + +void OnTTSResetTimeoutNotification::Run() { + LOG4CXX_INFO(logger_, "OnTTSResetTimeoutNotification::Run"); + + event_engine::Event event(hmi_apis::FunctionID::TTS_OnResetTimeout); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_tts_started_notification.cc b/src/components/application_manager/src/commands/hmi/on_tts_started_notification.cc new file mode 100644 index 0000000000..519fc290d9 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_tts_started_notification.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_tts_started_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnTTSStartedNotification::OnTTSStartedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnTTSStartedNotification::~OnTTSStartedNotification() { +} + +void OnTTSStartedNotification::Run() { + LOG4CXX_INFO(logger_, "OnTTSStartedNotification::Run"); + + ApplicationManagerImpl::instance()->Mute(kTTSSessionChanging); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_tts_stopped_notification.cc b/src/components/application_manager/src/commands/hmi/on_tts_stopped_notification.cc new file mode 100644 index 0000000000..b3e3683f32 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_tts_stopped_notification.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_tts_stopped_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +OnTTSStoppedNotification::OnTTSStoppedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnTTSStoppedNotification::~OnTTSStoppedNotification() { +} + +void OnTTSStoppedNotification::Run() { + LOG4CXX_INFO(logger_, "OnTTSStoppedNotification::Run"); + + event_engine::Event event(hmi_apis::FunctionID::TTS_Stopped); + event.set_smart_object(*message_); + event.raise(); + ApplicationManagerImpl::instance()->Unmute(kTTSSessionChanging); + +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ui_command_notification.cc b/src/components/application_manager/src/commands/hmi/on_ui_command_notification.cc new file mode 100644 index 0000000000..4ed5839e5f --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ui_command_notification.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ui_command_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnUICommandNotification::OnUICommandNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnUICommandNotification::~OnUICommandNotification() { +} + +void OnUICommandNotification::Run() { + LOG4CXX_INFO(logger_, "OnUICommandNotification::Run"); + + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnCommandID); + + (*message_)[strings::msg_params][strings::trigger_source] = + static_cast<int32_t>(mobile_apis::TriggerSource::TS_MENU); + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ui_keyboard_input_notification.cc b/src/components/application_manager/src/commands/hmi/on_ui_keyboard_input_notification.cc new file mode 100644 index 0000000000..45ff7425b7 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ui_keyboard_input_notification.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ui_keyboard_input_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnUIKeyBoardInputNotification::OnUIKeyBoardInputNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnUIKeyBoardInputNotification::~OnUIKeyBoardInputNotification() { +} + +void OnUIKeyBoardInputNotification::Run() { + LOG4CXX_INFO(logger_, "OnUIKeyBoardInputNotification::Run"); + + //prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + mobile_apis::FunctionID::OnKeyboardInputID; + SendNotificationToMobile(message_); +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ui_language_change_notification.cc b/src/components/application_manager/src/commands/hmi/on_ui_language_change_notification.cc new file mode 100644 index 0000000000..5756f50eb5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ui_language_change_notification.cc @@ -0,0 +1,94 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ui_language_change_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnUILanguageChangeNotification::OnUILanguageChangeNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnUILanguageChangeNotification::~OnUILanguageChangeNotification() { +} + +void OnUILanguageChangeNotification::Run() { + LOG4CXX_INFO(logger_, "OnUILanguageChangeNotification::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_active_ui_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][strings::language].asInt())); + + (*message_)[strings::msg_params][strings::hmi_display_language] = + (*message_)[strings::msg_params][strings::language]; + + (*message_)[strings::msg_params][strings::language] = + hmi_capabilities.active_vr_language(); + + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID); + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + + std::set<ApplicationSharedPtr>::iterator it = applications.begin(); + for (;applications.end() != it; ++it) { + ApplicationSharedPtr app = *it; + (*message_)[strings::params][strings::connection_key] = app->app_id(); + SendNotificationToMobile(message_); + + if (app->ui_language() != (*message_)[strings::msg_params] + [strings::hmi_display_language].asInt()) { + + MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + app->app_id(), + mobile_api::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE); + ApplicationManagerImpl::instance()->UnregisterApplication( + app->app_id(), mobile_apis::Result::SUCCESS, false); + } + } +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ui_reset_timeout_notification.cc b/src/components/application_manager/src/commands/hmi/on_ui_reset_timeout_notification.cc new file mode 100644 index 0000000000..357bfc4cb3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ui_reset_timeout_notification.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ui_reset_timeout_notification.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnUIResetTimeoutNotification::OnUIResetTimeoutNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnUIResetTimeoutNotification::~OnUIResetTimeoutNotification() { +} + +void OnUIResetTimeoutNotification::Run() { + LOG4CXX_INFO(logger_, "OnUIResetTimeoutNotification::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_OnResetTimeout); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_ui_touch_event_notification.cc b/src/components/application_manager/src/commands/hmi/on_ui_touch_event_notification.cc new file mode 100644 index 0000000000..7868e81193 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_ui_touch_event_notification.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_ui_touch_event_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +namespace hmi { + +OnUITouchEventNotification::OnUITouchEventNotification( + const MessageSharedPtr& message) : NotificationFromHMI(message) { +} + +OnUITouchEventNotification::~OnUITouchEventNotification() { +} + +void OnUITouchEventNotification::Run() { + LOG4CXX_INFO(logger_, "OnUITouchEventNotification::Run"); + + //prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + mobile_apis::FunctionID::OnTouchEventID; + SendNotificationToMobile(message_); +} + +} // namespace hmi + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_update_device_list.cc b/src/components/application_manager/src/commands/hmi/on_update_device_list.cc new file mode 100644 index 0000000000..a5b84748ef --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_update_device_list.cc @@ -0,0 +1,53 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_update_device_list.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnUpdateDeviceList::OnUpdateDeviceList(const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnUpdateDeviceList::~OnUpdateDeviceList() { +} + +void OnUpdateDeviceList::Run() { + LOG4CXX_INFO(logger_, "OnUpdateDeviceList::Run"); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_acc_pedal_position_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_acc_pedal_position_notification.cc new file mode 100644 index 0000000000..be0c4ebb60 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_acc_pedal_position_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_acc_pedal_position_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIAccPedalPositionNotification::OnVIAccPedalPositionNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIAccPedalPositionNotification::~OnVIAccPedalPositionNotification() { +} + +void OnVIAccPedalPositionNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIAccPedalPositionNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_belt_status_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_belt_status_notification.cc new file mode 100644 index 0000000000..688a5c1fb1 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_belt_status_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_belt_status_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIBeltStatusNotification::OnVIBeltStatusNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIBeltStatusNotification::~OnVIBeltStatusNotification() { +} + +void OnVIBeltStatusNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIBeltStatusNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_body_information_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_body_information_notification.cc new file mode 100644 index 0000000000..e80a2edcf3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_body_information_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_body_information_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIBodyInformationNotification::OnVIBodyInformationNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIBodyInformationNotification::~OnVIBodyInformationNotification() { +} + +void OnVIBodyInformationNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIBodyInformationNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_device_status_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_device_status_notification.cc new file mode 100644 index 0000000000..4669398da1 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_device_status_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_device_status_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIDeviceStatusNotification::OnVIDeviceStatusNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIDeviceStatusNotification::~OnVIDeviceStatusNotification() { +} + +void OnVIDeviceStatusNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIDeviceStatusNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_driver_braking_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_driver_braking_notification.cc new file mode 100644 index 0000000000..8b61d0af21 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_driver_braking_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_driver_braking_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIDriverBrakingNotification::OnVIDriverBrakingNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIDriverBrakingNotification::~OnVIDriverBrakingNotification() { +} + +void OnVIDriverBrakingNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIDriverBrakingNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_engine_torque_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_engine_torque_notification.cc new file mode 100644 index 0000000000..1b0989b1ec --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_engine_torque_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_engine_torque_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIEngineTorqueNotification::OnVIEngineTorqueNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIEngineTorqueNotification::~OnVIEngineTorqueNotification() { +} + +void OnVIEngineTorqueNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIEngineTorqueNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_external_temperature_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_external_temperature_notification.cc new file mode 100644 index 0000000000..f7a9213598 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_external_temperature_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_external_temperature_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIExternalTemperatureNotification::OnVIExternalTemperatureNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIExternalTemperatureNotification::~OnVIExternalTemperatureNotification() { +} + +void OnVIExternalTemperatureNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIExternalTemperatureNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_fuel_level_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_fuel_level_notification.cc new file mode 100644 index 0000000000..97d797b630 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_fuel_level_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_fuel_level_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIFuelLevelNotification::OnVIFuelLevelNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIFuelLevelNotification::~OnVIFuelLevelNotification() { +} + +void OnVIFuelLevelNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIFuelLevelNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_fuel_level_state_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_fuel_level_state_notification.cc new file mode 100644 index 0000000000..0024f17a80 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_fuel_level_state_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_fuel_level_state_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIFuelLevelStateNotification::OnVIFuelLevelStateNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIFuelLevelStateNotification::~OnVIFuelLevelStateNotification() { +} + +void OnVIFuelLevelStateNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIFuelLevelStateNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_gps_data_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_gps_data_notification.cc new file mode 100644 index 0000000000..5b7ec72977 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_gps_data_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_gps_data_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIGpsDataNotification::OnVIGpsDataNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIGpsDataNotification::~OnVIGpsDataNotification() { +} + +void OnVIGpsDataNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIGpsDataNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_head_lamp_status_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_head_lamp_status_notification.cc new file mode 100644 index 0000000000..355c00f0c9 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_head_lamp_status_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_head_lamp_status_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIHeadLampStatusNotification::OnVIHeadLampStatusNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIHeadLampStatusNotification::~OnVIHeadLampStatusNotification() { +} + +void OnVIHeadLampStatusNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIHeadLampStatusNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_instant_fuel_consumption_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_instant_fuel_consumption_notification.cc new file mode 100644 index 0000000000..17240bce6c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_instant_fuel_consumption_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_instant_fuel_consumption_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIInstantFuelConsumptionNotification::OnVIInstantFuelConsumptionNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIInstantFuelConsumptionNotification::~OnVIInstantFuelConsumptionNotification() { +} + +void OnVIInstantFuelConsumptionNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIInstantFuelConsumptionNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_my_key_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_my_key_notification.cc new file mode 100644 index 0000000000..1caaecb442 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_my_key_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_my_key_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIMyKeyNotification::OnVIMyKeyNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIMyKeyNotification::~OnVIMyKeyNotification() { +} + +void OnVIMyKeyNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIMyKeyNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_odometer_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_odometer_notification.cc new file mode 100644 index 0000000000..02127a1389 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_odometer_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_odometer_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIOdometerNotification::OnVIOdometerNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIOdometerNotification::~OnVIOdometerNotification() { +} + +void OnVIOdometerNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIOdometerNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_prndl_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_prndl_notification.cc new file mode 100644 index 0000000000..4692191cb3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_prndl_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_prndl_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIPrndlNotification::OnVIPrndlNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIPrndlNotification::~OnVIPrndlNotification() { +} + +void OnVIPrndlNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIPrndlNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_rpm_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_rpm_notification.cc new file mode 100644 index 0000000000..b16421903a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_rpm_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_rpm_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIRpmNotification::OnVIRpmNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIRpmNotification::~OnVIRpmNotification() { +} + +void OnVIRpmNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIRpmNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_speed_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_speed_notification.cc new file mode 100644 index 0000000000..6bc1e8b2cf --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_speed_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_speed_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVISpeedNotification::OnVISpeedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVISpeedNotification::~OnVISpeedNotification() { +} + +void OnVISpeedNotification::Run() { + LOG4CXX_INFO(logger_, "OnVISpeedNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_steering_wheel_angle_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_steering_wheel_angle_notification.cc new file mode 100644 index 0000000000..853b4eeea3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_steering_wheel_angle_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_steering_wheel_angle_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVISteeringWheelAngleNotification::OnVISteeringWheelAngleNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVISteeringWheelAngleNotification::~OnVISteeringWheelAngleNotification() { +} + +void OnVISteeringWheelAngleNotification::Run() { + LOG4CXX_INFO(logger_, "OnVISteeringWheelAngleNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_tire_pressure_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_tire_pressure_notification.cc new file mode 100644 index 0000000000..01ac7e9f8c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_tire_pressure_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_tire_pressure_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVITirePressureNotification::OnVITirePressureNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVITirePressureNotification::~OnVITirePressureNotification() { +} + +void OnVITirePressureNotification::Run() { + LOG4CXX_INFO(logger_, "OnVITirePressureNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_vehicle_data_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_vehicle_data_notification.cc new file mode 100644 index 0000000000..eda88ef602 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_vehicle_data_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_vehicle_data_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIVehicleDataNotification::OnVIVehicleDataNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIVehicleDataNotification::~OnVIVehicleDataNotification() { +} + +void OnVIVehicleDataNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIVehicleDataNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_vin_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_vin_notification.cc new file mode 100644 index 0000000000..546dc0d3cf --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_vin_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_vin_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIVinNotification::OnVIVinNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIVinNotification::~OnVIVinNotification() { +} + +void OnVIVinNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIVinNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vi_wiper_status_notification.cc b/src/components/application_manager/src/commands/hmi/on_vi_wiper_status_notification.cc new file mode 100644 index 0000000000..101427df0a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vi_wiper_status_notification.cc @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vi_wiper_status_notification.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVIWiperStatusNotification::OnVIWiperStatusNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVIWiperStatusNotification::~OnVIWiperStatusNotification() { +} + +void OnVIWiperStatusNotification::Run() { + LOG4CXX_INFO(logger_, "OnVIWiperStatusNotification::Run"); + + // prepare SmartObject for mobile factory + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnVehicleDataID); + + SendNotificationToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vr_command_notification.cc b/src/components/application_manager/src/commands/hmi/on_vr_command_notification.cc new file mode 100644 index 0000000000..99842b8524 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vr_command_notification.cc @@ -0,0 +1,101 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vr_command_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "config_profile/profile.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +OnVRCommandNotification::OnVRCommandNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVRCommandNotification::~OnVRCommandNotification() { +} + +void OnVRCommandNotification::Run() { + LOG4CXX_INFO(logger_, "OnVRCommandNotification::Run"); + + ApplicationSharedPtr active_app = ApplicationManagerImpl::instance() + ->active_application(); + const uint32_t cmd_id = (*message_)[strings::msg_params][strings::cmd_id] + .asUInt(); + uint32_t max_cmd_id = profile::Profile::instance()->max_cmd_id(); + + // Check if this is one of standart VR commands (i.e. "Help") + if (cmd_id > max_cmd_id + 1) { + LOG4CXX_INFO(logger_, "Switched App"); + MessageHelper::SendActivateAppToHMI(cmd_id - max_cmd_id); + return; + } + + // Check if this is "Help" + if (cmd_id == max_cmd_id + 1) { + return; + } + const uint32_t app_id = (*message_)[strings::msg_params][strings::app_id] + .asUInt(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + /* check if perform interaction is active + * if it is active we should sent to HMI DeleteCommand request + * and PerformInterActionResponse to mobile + */ + if (0 != app->is_perform_interaction_active()) { + event_engine::Event event(hmi_apis::FunctionID::VR_OnCommand); + event.set_smart_object(*message_); + event.raise(); + } else { + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnCommandID); + + (*message_)[strings::msg_params][strings::trigger_source] = + static_cast<int32_t>(mobile_apis::TriggerSource::TS_VR); + SendNotificationToMobile(message_); + } +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vr_language_change_notification.cc b/src/components/application_manager/src/commands/hmi/on_vr_language_change_notification.cc new file mode 100644 index 0000000000..92e7cb7b23 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vr_language_change_notification.cc @@ -0,0 +1,91 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vr_language_change_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVRLanguageChangeNotification::OnVRLanguageChangeNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVRLanguageChangeNotification::~OnVRLanguageChangeNotification() { +} + +void OnVRLanguageChangeNotification::Run() { + LOG4CXX_INFO(logger_, "OnVRLanguageChangeNotification::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_active_vr_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][strings::language].asInt())); + + (*message_)[strings::msg_params][strings::hmi_display_language] = + hmi_capabilities.active_ui_language(); + + (*message_)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::OnLanguageChangeID); + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + + std::set<ApplicationSharedPtr>::iterator it = applications.begin(); + for (;applications.end() != it; ++it) { + ApplicationSharedPtr app = (*it); + (*message_)[strings::params][strings::connection_key] = app->app_id(); + SendNotificationToMobile(message_); + if (static_cast<int32_t>(app->language()) + != (*message_)[strings::msg_params][strings::language].asInt()) { + app->set_hmi_level(mobile_api::HMILevel::HMI_NONE); + + MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + app->app_id(), + mobile_api::AppInterfaceUnregisteredReason::LANGUAGE_CHANGE); + ApplicationManagerImpl::instance()->UnregisterApplication( + app->app_id(), mobile_apis::Result::SUCCESS, false); + } + } +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vr_started_notification.cc b/src/components/application_manager/src/commands/hmi/on_vr_started_notification.cc new file mode 100644 index 0000000000..72f6767e8c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vr_started_notification.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vr_started_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnVRStartedNotification::OnVRStartedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVRStartedNotification::~OnVRStartedNotification() { +} + +void OnVRStartedNotification::Run() { + LOG4CXX_INFO(logger_, "OnVRStartedNotification::Run"); + + ApplicationManagerImpl::instance()->set_vr_session_started(true); + ApplicationManagerImpl::instance()->Mute(kVRSessionChanging); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/on_vr_stopped_notification.cc b/src/components/application_manager/src/commands/hmi/on_vr_stopped_notification.cc new file mode 100644 index 0000000000..46274a3b2e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/on_vr_stopped_notification.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/on_vr_stopped_notification.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +OnVRStoppedNotification::OnVRStoppedNotification( + const MessageSharedPtr& message) + : NotificationFromHMI(message) { +} + +OnVRStoppedNotification::~OnVRStoppedNotification() { +} + +void OnVRStoppedNotification::Run() { + LOG4CXX_INFO(logger_, "OnVRStoppedNotification::Run"); + + ApplicationManagerImpl::instance()->set_vr_session_started(false); + ApplicationManagerImpl::instance()->Unmute(kVRSessionChanging); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/request_from_hmi.cc b/src/components/application_manager/src/commands/hmi/request_from_hmi.cc new file mode 100644 index 0000000000..7b7f740904 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/request_from_hmi.cc @@ -0,0 +1,63 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/request_from_hmi.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +RequestFromHMI::RequestFromHMI(const MessageSharedPtr& message) + : CommandImpl(message) { + + // Replace HMI app id with Mobile connection id + ApplicationManagerImpl::instance()->ReplaceHMIByMobileAppId(*(message.get())); +} + +RequestFromHMI::~RequestFromHMI() { +} + +bool RequestFromHMI::Init() { + return true; +} + +bool RequestFromHMI::CleanUp() { + return true; +} + +void RequestFromHMI::Run() { +} + +} // namespace commands +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/request_to_hmi.cc b/src/components/application_manager/src/commands/hmi/request_to_hmi.cc new file mode 100644 index 0000000000..242118a417 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/request_to_hmi.cc @@ -0,0 +1,70 @@ +/** + Copyright (c) 2014, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/request_to_hmi.h" +#include "application_manager/application_manager_impl.h" +#include "config_profile/profile.h" + +namespace application_manager { + +namespace commands { + +RequestToHMI::RequestToHMI(const MessageSharedPtr& message) + : CommandImpl(message) { + // Replace Mobile connection id with HMI app id + ApplicationManagerImpl::instance()->ReplaceMobileByHMIAppId(*(message.get())); +} + +RequestToHMI::~RequestToHMI() { +} + +bool RequestToHMI::Init() { + return true; +} + +bool RequestToHMI::CleanUp() { + return true; +} + +void RequestToHMI::Run() { +} + +void RequestToHMI::SendRequest() { + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/response_from_hmi.cc b/src/components/application_manager/src/commands/hmi/response_from_hmi.cc new file mode 100644 index 0000000000..42bebb847d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/response_from_hmi.cc @@ -0,0 +1,108 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/response_from_hmi.h" +#include "application_manager/application_manager_impl.h" +#include "smart_objects/smart_object.h" + +namespace application_manager { + +namespace commands { + +ResponseFromHMI::ResponseFromHMI(const MessageSharedPtr& message) + : CommandImpl(message) { + //If it is error response, shift info + if ((*message)[strings::params].keyExists(hmi_response::message)) { + (*message)[strings::msg_params][strings::info] = + (*message)[strings::params][hmi_response::message]; + } + + // Replace HMI app id with Mobile connection id + ApplicationManagerImpl::instance()->ReplaceHMIByMobileAppId(*(message.get())); +} + +ResponseFromHMI::~ResponseFromHMI() { +} + +bool ResponseFromHMI::Init() { + return true; +} + +bool ResponseFromHMI::CleanUp() { + return true; +} + +void ResponseFromHMI::Run() { +} + +void ResponseFromHMI::SendResponseToMobile(const MessageSharedPtr& message) { + (*message)[strings::params][strings::message_type] = MessageType::kResponse; + + ApplicationManagerImpl::instance()->ManageMobileCommand(message); +} + +void ResponseFromHMI::CreateHMIRequest( + const hmi_apis::FunctionID::eType& function_id, + const NsSmart::SmartObject& msg_params) const { + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + new NsSmartDeviceLink::NsSmartObjects::SmartObject; + + if (!result) { + LOG4CXX_ERROR(logger_, "Memory allocation failed."); + return; + } + + // get hmi correlation id for chaining further request from this object + const uint32_t hmi_correlation_id_ = ApplicationManagerImpl::instance() + ->GetNextHMICorrelationID(); + + NsSmartDeviceLink::NsSmartObjects::SmartObject& request = *result; + request[strings::params][strings::message_type] = MessageType::kRequest; + request[strings::params][strings::function_id] = function_id; + request[strings::params][strings::correlation_id] = hmi_correlation_id_; + request[strings::params][strings::protocol_version] = + CommandImpl::protocol_version_; + request[strings::params][strings::protocol_type] = + CommandImpl::hmi_protocol_type_; + + request[strings::msg_params] = msg_params; + + if (!ApplicationManagerImpl::instance()->ManageHMICommand(result)) { + LOG4CXX_ERROR(logger_, "Unable to send request"); + return; + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/response_to_hmi.cc b/src/components/application_manager/src/commands/hmi/response_to_hmi.cc new file mode 100644 index 0000000000..d18987428e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/response_to_hmi.cc @@ -0,0 +1,66 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/response_to_hmi.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +ResponseToHMI::ResponseToHMI(const MessageSharedPtr& message) + : CommandImpl(message) { + // Replace Mobile connection id with HMI app id + ApplicationManagerImpl::instance()->ReplaceMobileByHMIAppId(*(message.get())); +} + +ResponseToHMI::~ResponseToHMI() { +} + +bool ResponseToHMI::Init() { + return true; +} + +bool ResponseToHMI::CleanUp() { + return true; +} + +void ResponseToHMI::Run() { + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc b/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc new file mode 100644 index 0000000000..72abf233ce --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_activate_app_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_activate_app_request.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +SDLActivateAppRequest::SDLActivateAppRequest(const MessageSharedPtr& message) + : RequestFromHMI(message) { +} + +SDLActivateAppRequest::~SDLActivateAppRequest() { +} + +void SDLActivateAppRequest::Run() { + LOG4CXX_INFO(logger_, "SDLActivateAppRequest::Run"); + policy::PolicyHandler::instance()->OnActivateApp( + (*message_)[strings::msg_params][strings::app_id].asUInt(), + (*message_)[strings::params][strings::correlation_id].asInt()); +} + +} // namespace commands +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/sdl_activate_app_response.cc b/src/components/application_manager/src/commands/hmi/sdl_activate_app_response.cc new file mode 100644 index 0000000000..46eb402f41 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_activate_app_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_activate_app_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SDLActivateAppResponse::SDLActivateAppResponse( + const MessageSharedPtr& message): ResponseToHMI(message) { +} + +SDLActivateAppResponse::~SDLActivateAppResponse() { +} + +void SDLActivateAppResponse::Run() { + LOG4CXX_INFO(logger_, "SDLActivateAppResponse::Run"); + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc b/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc new file mode 100644 index 0000000000..7eb5a268ac --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_request.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_get_list_of_permissions_request.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +SDLGetListOfPermissionsRequest::SDLGetListOfPermissionsRequest( + const MessageSharedPtr& message) + : RequestFromHMI(message) { +} + +SDLGetListOfPermissionsRequest::~SDLGetListOfPermissionsRequest() { +} + +void SDLGetListOfPermissionsRequest::Run() { + LOG4CXX_INFO(logger_, "SDLGetListOfPermissionsRequest::Run"); + uint32_t connection_key = 0; + if ((*message_)[strings::msg_params].keyExists(strings::app_id)) { + connection_key = (*message_)[strings::msg_params][strings::app_id].asUInt(); + } + policy::PolicyHandler::instance()->OnGetListOfPermissions( + connection_key, + (*message_)[strings::params][strings::correlation_id].asUInt()); +} + +} // namespace commands +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_response.cc b/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_response.cc new file mode 100644 index 0000000000..da474cb128 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_get_list_of_permissions_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_get_list_of_permissions_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SDLGetListOfPermissionsResponse::SDLGetListOfPermissionsResponse( + const MessageSharedPtr& message): ResponseToHMI(message) { +} + +SDLGetListOfPermissionsResponse::~SDLGetListOfPermissionsResponse() { +} + +void SDLGetListOfPermissionsResponse::Run() { + LOG4CXX_INFO(logger_, "SDLGetListOfPermissionsResponse::Run"); + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc b/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc new file mode 100644 index 0000000000..cc5fbc63ae --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_get_status_update_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_get_status_update_request.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +SDLGetStatusUpdateRequest::SDLGetStatusUpdateRequest(const MessageSharedPtr& message) + : RequestFromHMI(message) { +} + +SDLGetStatusUpdateRequest::~SDLGetStatusUpdateRequest() { +} + +void SDLGetStatusUpdateRequest::Run() { + LOG4CXX_INFO(logger_, "SDLGetStatusUpdateRequest::Run"); + policy::PolicyHandler::instance()->OnGetStatusUpdate( + (*message_)[strings::params][strings::correlation_id].asUInt()); +} + +} // namespace commands +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_status_update_response.cc b/src/components/application_manager/src/commands/hmi/sdl_get_status_update_response.cc new file mode 100644 index 0000000000..08d8d315a5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_get_status_update_response.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_get_status_update_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SDLGetStatusUpdateResponse::SDLGetStatusUpdateResponse( + const MessageSharedPtr& message): ResponseToHMI(message) { +} + +SDLGetStatusUpdateResponse::~SDLGetStatusUpdateResponse() { +} + +void SDLGetStatusUpdateResponse::Run() { + LOG4CXX_INFO(logger_, "SDLGetStatusUpdateResponse::Run"); + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands +} // namespace application_manager + + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc b/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc new file mode 100644 index 0000000000..047d6bf846 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_request.cc @@ -0,0 +1,93 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_get_user_friendly_message_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +SDLGetUserFriendlyMessageRequest::SDLGetUserFriendlyMessageRequest( + const MessageSharedPtr& message) + : RequestFromHMI(message) { +} + +SDLGetUserFriendlyMessageRequest::~SDLGetUserFriendlyMessageRequest() { +} + +void SDLGetUserFriendlyMessageRequest::Run() { + LOG4CXX_INFO(logger_, "SDLGetUserFriendlyMessageRequest::Run"); + const std::string messageCodes = "messageCodes"; + if (!(*message_)[strings::msg_params].keyExists(messageCodes)) { + LOG4CXX_WARN(logger_, + "Mandatory parameter '"+messageCodes+"'' is missing"); + return; + } + smart_objects::SmartArray* msg = + (*message_)[strings::msg_params][messageCodes].asArray(); + + std::vector<std::string> msg_codes; + + smart_objects::SmartArray::const_iterator it = msg->begin(); + smart_objects::SmartArray::const_iterator it_end = msg->end(); + for (; it != it_end; ++it) { + msg_codes.push_back((*it).asString()); + } + + std::string required_language; + if ((*message_)[strings::msg_params].keyExists(strings::language)) { + uint32_t lang_code = (*message_)[strings::msg_params][strings::language] + .asUInt(); + required_language = + application_manager::MessageHelper::CommonLanguageToString( + static_cast<hmi_apis::Common_Language::eType>(lang_code)); + } else { + hmi_apis::Common_Language::eType ui_language = + application_manager::ApplicationManagerImpl::instance() + ->hmi_capabilities().active_ui_language(); + + required_language = + application_manager::MessageHelper::CommonLanguageToString(ui_language); + } + + policy::PolicyHandler::instance()->OnGetUserFriendlyMessage( + msg_codes, required_language, + (*message_)[strings::params][strings::correlation_id].asInt()); +} + +} // namespace commands +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_response.cc b/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_response.cc new file mode 100644 index 0000000000..c849204cc3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_get_user_friendly_message_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_get_user_friendly_message_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SDLGetUserFriendlyMessageResponse::SDLGetUserFriendlyMessageResponse( + const MessageSharedPtr& message): ResponseToHMI(message) { +} + +SDLGetUserFriendlyMessageResponse::~SDLGetUserFriendlyMessageResponse() { +} + +void SDLGetUserFriendlyMessageResponse::Run() { + LOG4CXX_INFO(logger_, "SDLGetUserFriendlyMessageResponse::Run"); + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/sdl_policy_update.cc b/src/components/application_manager/src/commands/hmi/sdl_policy_update.cc new file mode 100644 index 0000000000..4779e106c5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_policy_update.cc @@ -0,0 +1,53 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_policy_update.h" + +namespace application_manager { + +namespace commands { + +SDLPolicyUpdate::SDLPolicyUpdate( + const MessageSharedPtr& message): RequestToHMI(message) { +} + +SDLPolicyUpdate::~SDLPolicyUpdate() { +} + +void SDLPolicyUpdate::Run() { + LOG4CXX_INFO(logger_, "SDLPolicyUpdate::Run"); + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/sdl_policy_update_response.cc b/src/components/application_manager/src/commands/hmi/sdl_policy_update_response.cc new file mode 100644 index 0000000000..a3db3a9047 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/sdl_policy_update_response.cc @@ -0,0 +1,51 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/sdl_policy_update_response.h" + +namespace application_manager { + +namespace commands { +SDLPolicyUpdateResponse::SDLPolicyUpdateResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +SDLPolicyUpdateResponse::~SDLPolicyUpdateResponse() { +} + +void SDLPolicyUpdateResponse::Run() { + LOG4CXX_INFO(logger_, "SDLPolicyUpdateResponse::Run"); + // TODO(PV): add some logic here +} +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_change_registration_request.cc b/src/components/application_manager/src/commands/hmi/tts_change_registration_request.cc new file mode 100644 index 0000000000..638503d162 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_change_registration_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_change_registration_request.h" + +namespace application_manager { + +namespace commands { + +TTSChangeRegistrationRequest::TTSChangeRegistrationRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSChangeRegistrationRequest::~TTSChangeRegistrationRequest() { +} + +void TTSChangeRegistrationRequest::Run() { + LOG4CXX_INFO(logger_, "TTSChangeRegistrationRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_change_registration_response.cc b/src/components/application_manager/src/commands/hmi/tts_change_registration_response.cc new file mode 100644 index 0000000000..67e48b4ed5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_change_registration_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_change_registration_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +TTSChangeRegistratioResponse::TTSChangeRegistratioResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSChangeRegistratioResponse::~TTSChangeRegistratioResponse() { +} + +void TTSChangeRegistratioResponse::Run() { + LOG4CXX_INFO(logger_, "TTSChangeRegistratioResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::TTS_ChangeRegistration); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_get_capabilities_request.cc b/src/components/application_manager/src/commands/hmi/tts_get_capabilities_request.cc new file mode 100644 index 0000000000..59cf50b38d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_get_capabilities_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_get_capabilities_request.h" + +namespace application_manager { + +namespace commands { + +TTSGetCapabilitiesRequest::TTSGetCapabilitiesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSGetCapabilitiesRequest::~TTSGetCapabilitiesRequest() { +} + +void TTSGetCapabilitiesRequest::Run() { + LOG4CXX_INFO(logger_, "TTSGetCapabilitiesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_get_capabilities_response.cc b/src/components/application_manager/src/commands/hmi/tts_get_capabilities_response.cc new file mode 100644 index 0000000000..f7309822d8 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_get_capabilities_response.cc @@ -0,0 +1,67 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_get_capabilities_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +TTSGetCapabilitiesResponse::TTSGetCapabilitiesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSGetCapabilitiesResponse::~TTSGetCapabilitiesResponse() { +} + +void TTSGetCapabilitiesResponse::Run() { + LOG4CXX_INFO(logger_, "TTSGetCapabilitiesResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + if ((*message_)[strings::msg_params].keyExists(hmi_response::speech_capabilities)) { + hmi_capabilities.set_speech_capabilities( + (*message_)[strings::msg_params][hmi_response::speech_capabilities]); + } + if ((*message_)[strings::msg_params].keyExists( + hmi_response::prerecorded_speech_capabilities)) { + hmi_capabilities.set_prerecorded_speech( + (*message_)[strings::msg_params] + [hmi_response::prerecorded_speech_capabilities]); + } + +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_get_language_request.cc b/src/components/application_manager/src/commands/hmi/tts_get_language_request.cc new file mode 100644 index 0000000000..9f2fe7134a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_get_language_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_get_language_request.h" + +namespace application_manager { + +namespace commands { + +TTSGetLanguageRequest::TTSGetLanguageRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSGetLanguageRequest::~TTSGetLanguageRequest() { +} + +void TTSGetLanguageRequest::Run() { + LOG4CXX_INFO(logger_, "TTSGetLanguageRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_get_language_response.cc b/src/components/application_manager/src/commands/hmi/tts_get_language_response.cc new file mode 100644 index 0000000000..e26fa87739 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_get_language_response.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_get_language_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +TTSGetLanguageResponse::TTSGetLanguageResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSGetLanguageResponse::~TTSGetLanguageResponse() { +} + +void TTSGetLanguageResponse::Run() { + LOG4CXX_INFO(logger_, "TTSGetLanguageResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_active_tts_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][hmi_response::language].asInt())); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_get_supported_languages_request.cc b/src/components/application_manager/src/commands/hmi/tts_get_supported_languages_request.cc new file mode 100644 index 0000000000..08c1d82448 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_get_supported_languages_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_get_supported_languages_request.h" + +namespace application_manager { + +namespace commands { + +TTSGetSupportedLanguagesRequest::TTSGetSupportedLanguagesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSGetSupportedLanguagesRequest::~TTSGetSupportedLanguagesRequest() { +} + +void TTSGetSupportedLanguagesRequest::Run() { + LOG4CXX_INFO(logger_, "TTSGetSupportedLanguagesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_get_supported_languages_response.cc b/src/components/application_manager/src/commands/hmi/tts_get_supported_languages_response.cc new file mode 100644 index 0000000000..aa041f66b3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_get_supported_languages_response.cc @@ -0,0 +1,66 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_get_supported_languages_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +TTSGetSupportedLanguagesResponse::TTSGetSupportedLanguagesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSGetSupportedLanguagesResponse::~TTSGetSupportedLanguagesResponse() { +} + +void TTSGetSupportedLanguagesResponse::Run() { + LOG4CXX_INFO(logger_, "TTSGetSupportedLanguagesResponse::Run"); + + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*message_)[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS == code) { + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_tts_supported_languages( + (*message_)[strings::msg_params][hmi_response::languages]); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_is_ready_request.cc b/src/components/application_manager/src/commands/hmi/tts_is_ready_request.cc new file mode 100644 index 0000000000..7733de4887 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_is_ready_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_is_ready_request.h" + +namespace application_manager { + +namespace commands { + +TTSIsReadyRequest::TTSIsReadyRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSIsReadyRequest::~TTSIsReadyRequest() { +} + +void TTSIsReadyRequest::Run() { + LOG4CXX_INFO(logger_, "TTSIsReadyRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_is_ready_response.cc b/src/components/application_manager/src/commands/hmi/tts_is_ready_response.cc new file mode 100644 index 0000000000..fb3cb4858f --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_is_ready_response.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_is_ready_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +TTSIsReadyResponse::TTSIsReadyResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSIsReadyResponse::~TTSIsReadyResponse() { +} + +void TTSIsReadyResponse::Run() { + LOG4CXX_INFO(logger_, "TTSIsReadyResponse::Run"); + smart_objects::SmartObject& object = *message_; + + bool is_available = false; + if (object[strings::msg_params].keyExists(strings::available)) { + is_available = object[strings::msg_params][strings::available].asBool(); + } + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + hmi_capabilities.set_is_tts_cooperating(is_available); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_set_global_properties_request.cc b/src/components/application_manager/src/commands/hmi/tts_set_global_properties_request.cc new file mode 100644 index 0000000000..04f1380d91 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_set_global_properties_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_set_global_properties_request.h" + +namespace application_manager { + +namespace commands { + +TTSSetGlobalPropertiesRequest::TTSSetGlobalPropertiesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSSetGlobalPropertiesRequest::~TTSSetGlobalPropertiesRequest() { +} + +void TTSSetGlobalPropertiesRequest::Run() { + LOG4CXX_INFO(logger_, "TTSSetGlobalPropertiesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_set_global_properties_response.cc b/src/components/application_manager/src/commands/hmi/tts_set_global_properties_response.cc new file mode 100644 index 0000000000..c90655186f --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_set_global_properties_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_set_global_properties_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +TTSSetGlobalPropertiesResponse::TTSSetGlobalPropertiesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSSetGlobalPropertiesResponse::~TTSSetGlobalPropertiesResponse() { +} + +void TTSSetGlobalPropertiesResponse::Run() { + LOG4CXX_INFO(logger_, "TTSSetGlobalPropertiesResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::TTS_SetGlobalProperties); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_speak_request.cc b/src/components/application_manager/src/commands/hmi/tts_speak_request.cc new file mode 100644 index 0000000000..9b4bd68585 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_speak_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_speak_request.h" + +namespace application_manager { + +namespace commands { + +TTSSpeakRequest::TTSSpeakRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSSpeakRequest::~TTSSpeakRequest() { +} + +void TTSSpeakRequest::Run() { + LOG4CXX_INFO(logger_, "TTSSpeakRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_speak_response.cc b/src/components/application_manager/src/commands/hmi/tts_speak_response.cc new file mode 100644 index 0000000000..9b9e43dbe8 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_speak_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_speak_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +TTSSpeakResponse::TTSSpeakResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSSpeakResponse::~TTSSpeakResponse() { +} + +void TTSSpeakResponse::Run() { + LOG4CXX_INFO(logger_, "TTSSpeakResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::TTS_Speak); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/tts_stop_speaking_request.cc b/src/components/application_manager/src/commands/hmi/tts_stop_speaking_request.cc new file mode 100644 index 0000000000..107cb7933b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_stop_speaking_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_stop_speaking_request.h" + +namespace application_manager { + +namespace commands { + +TTSStopSpeakingRequest::TTSStopSpeakingRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +TTSStopSpeakingRequest::~TTSStopSpeakingRequest() { +} + +void TTSStopSpeakingRequest::Run() { + LOG4CXX_INFO(logger_, "TTSStopSpeakingRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/tts_stop_speaking_response.cc b/src/components/application_manager/src/commands/hmi/tts_stop_speaking_response.cc new file mode 100644 index 0000000000..9bd4f89660 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/tts_stop_speaking_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/tts_stop_speaking_response.h" + +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +TTSStopSpeakingResponse::TTSStopSpeakingResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +TTSStopSpeakingResponse::~TTSStopSpeakingResponse() { +} + +void TTSStopSpeakingResponse::Run() { + LOG4CXX_INFO(logger_, "TTSStopSpeakingResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::TTS_StopSpeaking); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_add_command_request.cc b/src/components/application_manager/src/commands/hmi/ui_add_command_request.cc new file mode 100644 index 0000000000..9aa5d2e2d3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_add_command_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_add_command_request.h" + +namespace application_manager { + +namespace commands { + +UIAddCommandRequest::UIAddCommandRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIAddCommandRequest::~UIAddCommandRequest() { +} + +void UIAddCommandRequest::Run() { + LOG4CXX_INFO(logger_, "UIAddCommandRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_add_command_response.cc b/src/components/application_manager/src/commands/hmi/ui_add_command_response.cc new file mode 100644 index 0000000000..21b34e0637 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_add_command_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_add_command_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIAddCommandResponse::UIAddCommandResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIAddCommandResponse::~UIAddCommandResponse() { +} + +void UIAddCommandResponse::Run() { + LOG4CXX_INFO(logger_, "UIAddCommandResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_AddCommand); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_add_submenu_request.cc b/src/components/application_manager/src/commands/hmi/ui_add_submenu_request.cc new file mode 100644 index 0000000000..7a9c5c6fed --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_add_submenu_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_add_submenu_request.h" + +namespace application_manager { + +namespace commands { + +UIAddSubmenuRequest::UIAddSubmenuRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIAddSubmenuRequest::~UIAddSubmenuRequest() { +} + +void UIAddSubmenuRequest::Run() { + LOG4CXX_INFO(logger_, "UIAddCommandRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_add_submenu_response.cc b/src/components/application_manager/src/commands/hmi/ui_add_submenu_response.cc new file mode 100644 index 0000000000..af88de2b48 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_add_submenu_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_add_submenu_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIAddSubmenuResponse::UIAddSubmenuResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIAddSubmenuResponse::~UIAddSubmenuResponse() { +} + +void UIAddSubmenuResponse::Run() { + LOG4CXX_INFO(logger_, "UIAddSubmenuResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_AddSubMenu); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_alert_request.cc b/src/components/application_manager/src/commands/hmi/ui_alert_request.cc new file mode 100644 index 0000000000..f8c9ed5708 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_alert_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_alert_request.h" + +namespace application_manager { + +namespace commands { + +UIAlertRequest::UIAlertRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIAlertRequest::~UIAlertRequest() { +} + +void UIAlertRequest::Run() { + LOG4CXX_INFO(logger_, "UIAlertRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_alert_response.cc b/src/components/application_manager/src/commands/hmi/ui_alert_response.cc new file mode 100644 index 0000000000..289b90d290 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_alert_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_alert_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIAlertResponse::UIAlertResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIAlertResponse::~UIAlertResponse() { +} + +void UIAlertResponse::Run() { + LOG4CXX_INFO(logger_, "UIAlertResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_Alert); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_change_registration_request.cc b/src/components/application_manager/src/commands/hmi/ui_change_registration_request.cc new file mode 100644 index 0000000000..fbba2b4023 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_change_registration_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_change_registration_request.h" + +namespace application_manager { + +namespace commands { + +UIChangeRegistrationRequest::UIChangeRegistrationRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIChangeRegistrationRequest::~UIChangeRegistrationRequest() { +} + +void UIChangeRegistrationRequest::Run() { + LOG4CXX_INFO(logger_, "UIChangeRegistrationRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_change_registration_response.cc b/src/components/application_manager/src/commands/hmi/ui_change_registration_response.cc new file mode 100644 index 0000000000..16447077dd --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_change_registration_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_change_registration_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIChangeRegistratioResponse::UIChangeRegistratioResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIChangeRegistratioResponse::~UIChangeRegistratioResponse() { +} + +void UIChangeRegistratioResponse::Run() { + LOG4CXX_INFO(logger_, "UIChangeRegistratioResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_ChangeRegistration); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_delete_command_request.cc b/src/components/application_manager/src/commands/hmi/ui_delete_command_request.cc new file mode 100644 index 0000000000..23fb4c67f5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_delete_command_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_delete_command_request.h" + +namespace application_manager { + +namespace commands { + +UIDeleteCommandRequest::UIDeleteCommandRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIDeleteCommandRequest::~UIDeleteCommandRequest() { +} + +void UIDeleteCommandRequest::Run() { + LOG4CXX_INFO(logger_, "UIDeleteCommandRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_delete_command_response.cc b/src/components/application_manager/src/commands/hmi/ui_delete_command_response.cc new file mode 100644 index 0000000000..0ac32877c4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_delete_command_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_delete_command_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIDeleteCommandResponse::UIDeleteCommandResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIDeleteCommandResponse::~UIDeleteCommandResponse() { +} + +void UIDeleteCommandResponse::Run() { + LOG4CXX_INFO(logger_, "UIDeleteCommandResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_DeleteCommand); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_delete_submenu_request.cc b/src/components/application_manager/src/commands/hmi/ui_delete_submenu_request.cc new file mode 100644 index 0000000000..41f356b981 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_delete_submenu_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_delete_submenu_request.h" + +namespace application_manager { + +namespace commands { + +UIDeleteSubmenuRequest::UIDeleteSubmenuRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIDeleteSubmenuRequest::~UIDeleteSubmenuRequest() { +} + +void UIDeleteSubmenuRequest::Run() { + LOG4CXX_INFO(logger_, "UIDeleteSubmenuRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_delete_submenu_response.cc b/src/components/application_manager/src/commands/hmi/ui_delete_submenu_response.cc new file mode 100644 index 0000000000..5a3359b722 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_delete_submenu_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_delete_submenu_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIDeleteSubmenuResponse::UIDeleteSubmenuResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIDeleteSubmenuResponse::~UIDeleteSubmenuResponse() { +} + +void UIDeleteSubmenuResponse::Run() { + LOG4CXX_INFO(logger_, "UIDeleteSubmenuResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_DeleteSubMenu); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_end_audio_pass_thru_request.cc b/src/components/application_manager/src/commands/hmi/ui_end_audio_pass_thru_request.cc new file mode 100644 index 0000000000..4c93f9235b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_end_audio_pass_thru_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_end_audio_pass_thru_request.h" + +namespace application_manager { + +namespace commands { + +UIEndAudioPassThruRequest::UIEndAudioPassThruRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIEndAudioPassThruRequest::~UIEndAudioPassThruRequest() { +} + +void UIEndAudioPassThruRequest::Run() { + LOG4CXX_INFO(logger_, "UIEndAudioPassThruRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_end_audio_pass_thru_response.cc b/src/components/application_manager/src/commands/hmi/ui_end_audio_pass_thru_response.cc new file mode 100644 index 0000000000..e560ae293a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_end_audio_pass_thru_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_end_audio_pass_thru_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIEndAudioPassThruResponse::UIEndAudioPassThruResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIEndAudioPassThruResponse::~UIEndAudioPassThruResponse() { +} + +void UIEndAudioPassThruResponse::Run() { + LOG4CXX_INFO(logger_, "UIEndAudioPassThruResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_EndAudioPassThru); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_get_capabilities_request.cc b/src/components/application_manager/src/commands/hmi/ui_get_capabilities_request.cc new file mode 100644 index 0000000000..b9f1b6917c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_get_capabilities_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_get_capabilities_request.h" + +namespace application_manager { + +namespace commands { + +UIGetCapabilitiesRequest::UIGetCapabilitiesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIGetCapabilitiesRequest::~UIGetCapabilitiesRequest() { +} + +void UIGetCapabilitiesRequest::Run() { + LOG4CXX_INFO(logger_, "UIGetCapabilitiesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc b/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc new file mode 100644 index 0000000000..0663bf033e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_get_capabilities_response.cc @@ -0,0 +1,75 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_get_capabilities_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +UIGetCapabilitiesResponse::UIGetCapabilitiesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIGetCapabilitiesResponse::~UIGetCapabilitiesResponse() { +} + +void UIGetCapabilitiesResponse::Run() { + LOG4CXX_INFO(logger_, "UIGetCapabilitiesResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_display_capabilities( + (*message_)[strings::msg_params][hmi_response::display_capabilities]); + + hmi_capabilities.set_hmi_zone_capabilities( + (*message_)[strings::msg_params][hmi_response::hmi_zone_capabilities]); + + if ((*message_)[strings::msg_params].keyExists( + hmi_response::soft_button_capabilities)) { + hmi_capabilities.set_soft_button_capabilities( + (*message_)[strings::msg_params][hmi_response::soft_button_capabilities]); + } + + if ((*message_)[strings::msg_params].keyExists( + strings::audio_pass_thru_capabilities)) { + + hmi_capabilities.set_audio_pass_thru_capabilities( + (*message_)[strings::msg_params][strings::audio_pass_thru_capabilities]); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_get_language_request.cc b/src/components/application_manager/src/commands/hmi/ui_get_language_request.cc new file mode 100644 index 0000000000..ffca242d43 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_get_language_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_get_language_request.h" + +namespace application_manager { + +namespace commands { + +UIGetLanguageRequest::UIGetLanguageRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIGetLanguageRequest::~UIGetLanguageRequest() { +} + +void UIGetLanguageRequest::Run() { + LOG4CXX_INFO(logger_, "UIGetLanguageRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_get_language_response.cc b/src/components/application_manager/src/commands/hmi/ui_get_language_response.cc new file mode 100644 index 0000000000..20435d788b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_get_language_response.cc @@ -0,0 +1,60 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_get_language_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIGetLanguageResponse::UIGetLanguageResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIGetLanguageResponse::~UIGetLanguageResponse() { +} + +void UIGetLanguageResponse::Run() { + LOG4CXX_INFO(logger_, "UIGetLanguageResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_active_ui_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][hmi_response::language].asInt())); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_get_supported_languages_request.cc b/src/components/application_manager/src/commands/hmi/ui_get_supported_languages_request.cc new file mode 100644 index 0000000000..455486ef6c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_get_supported_languages_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_get_supported_languages_request.h" + +namespace application_manager { + +namespace commands { + +UIGetSupportedLanguagesRequest::UIGetSupportedLanguagesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIGetSupportedLanguagesRequest::~UIGetSupportedLanguagesRequest() { +} + +void UIGetSupportedLanguagesRequest::Run() { + LOG4CXX_INFO(logger_, "UIGetSupportedLanguagesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_get_supported_languages_response.cc b/src/components/application_manager/src/commands/hmi/ui_get_supported_languages_response.cc new file mode 100644 index 0000000000..8492cfca5b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_get_supported_languages_response.cc @@ -0,0 +1,66 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_get_supported_languages_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIGetSupportedLanguagesResponse::UIGetSupportedLanguagesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIGetSupportedLanguagesResponse::~UIGetSupportedLanguagesResponse() { +} + +void UIGetSupportedLanguagesResponse::Run() { + LOG4CXX_INFO(logger_, "UIGetSupportedLanguagesResponse::Run"); + + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*message_)[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS == code) { + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_ui_supported_languages( + (*message_)[strings::msg_params][hmi_response::languages]); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_is_ready_request.cc b/src/components/application_manager/src/commands/hmi/ui_is_ready_request.cc new file mode 100644 index 0000000000..50d0ddd95a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_is_ready_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_is_ready_request.h" + +namespace application_manager { + +namespace commands { + +UIIsReadyRequest::UIIsReadyRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIIsReadyRequest::~UIIsReadyRequest() { +} + +void UIIsReadyRequest::Run() { + LOG4CXX_INFO(logger_, "UIIsReadyRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_is_ready_response.cc b/src/components/application_manager/src/commands/hmi/ui_is_ready_response.cc new file mode 100644 index 0000000000..97d11b6022 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_is_ready_response.cc @@ -0,0 +1,63 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_is_ready_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +UIIsReadyResponse::UIIsReadyResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIIsReadyResponse::~UIIsReadyResponse() { +} + +void UIIsReadyResponse::Run() { + LOG4CXX_INFO(logger_, "UIIsReadyResponse::Run"); + smart_objects::SmartObject& object = *message_; + + bool is_available = false; + if (object[strings::msg_params].keyExists(strings::available)) { + is_available = object[strings::msg_params][strings::available].asBool(); + } + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_is_ui_cooperating(is_available); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_perform_audio_pass_thru_request.cc b/src/components/application_manager/src/commands/hmi/ui_perform_audio_pass_thru_request.cc new file mode 100644 index 0000000000..cf77703a9b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_perform_audio_pass_thru_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_perform_audio_pass_thru_request.h" + +namespace application_manager { + +namespace commands { + +UIPerformAudioPassThruRequest::UIPerformAudioPassThruRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIPerformAudioPassThruRequest::~UIPerformAudioPassThruRequest() { +} + +void UIPerformAudioPassThruRequest::Run() { + LOG4CXX_INFO(logger_, "UIPerformAudioPassThruRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_perform_audio_pass_thru_response.cc b/src/components/application_manager/src/commands/hmi/ui_perform_audio_pass_thru_response.cc new file mode 100644 index 0000000000..36d4c507b5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_perform_audio_pass_thru_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_perform_audio_pass_thru_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +UIPerformAudioPassThruResponse::UIPerformAudioPassThruResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIPerformAudioPassThruResponse::~UIPerformAudioPassThruResponse() { +} + +void UIPerformAudioPassThruResponse::Run() { + LOG4CXX_INFO(logger_, "UIPerformAudioPassThruResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_PerformAudioPassThru); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_perform_interaction_request.cc b/src/components/application_manager/src/commands/hmi/ui_perform_interaction_request.cc new file mode 100644 index 0000000000..09f98ec036 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_perform_interaction_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_perform_interaction_request.h" + +namespace application_manager { + +namespace commands { + +UIPerformInteractionRequest::UIPerformInteractionRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIPerformInteractionRequest::~UIPerformInteractionRequest() { +} + +void UIPerformInteractionRequest::Run() { + LOG4CXX_INFO(logger_, "UIPerformInteractionRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_perform_interaction_response.cc b/src/components/application_manager/src/commands/hmi/ui_perform_interaction_response.cc new file mode 100644 index 0000000000..2f5f6ead57 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_perform_interaction_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_perform_interaction_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIPerformInteractionResponse::UIPerformInteractionResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIPerformInteractionResponse::~UIPerformInteractionResponse() { +} + +void UIPerformInteractionResponse::Run() { + LOG4CXX_INFO(logger_, "UIPerformInteractionResponse::Run"); + event_engine::Event event(hmi_apis::FunctionID::UI_PerformInteraction); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_scrollable_message_request.cc b/src/components/application_manager/src/commands/hmi/ui_scrollable_message_request.cc new file mode 100644 index 0000000000..ac34dd236f --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_scrollable_message_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_scrollable_message_request.h" + +namespace application_manager { + +namespace commands { + +UIScrollableMessageRequest::UIScrollableMessageRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIScrollableMessageRequest::~UIScrollableMessageRequest() { +} + +void UIScrollableMessageRequest::Run() { + LOG4CXX_INFO(logger_, "UIScrollableMessageRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_scrollable_message_response.cc b/src/components/application_manager/src/commands/hmi/ui_scrollable_message_response.cc new file mode 100644 index 0000000000..182d512c8c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_scrollable_message_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_scrollable_message_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UIScrollableMessageResponse::UIScrollableMessageResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIScrollableMessageResponse::~UIScrollableMessageResponse() { +} + +void UIScrollableMessageResponse::Run() { + LOG4CXX_INFO(logger_, "UIScrollableMessageResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_ScrollableMessage); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_set_display_layout_request.cc b/src/components/application_manager/src/commands/hmi/ui_set_display_layout_request.cc new file mode 100644 index 0000000000..3dea853486 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_display_layout_request.cc @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_display_layout_request.h" + +namespace application_manager { + +namespace commands { + +UiSetDisplayLayoutRequest::UiSetDisplayLayoutRequest( + const MessageSharedPtr& message): RequestToHMI(message) { +} + +UiSetDisplayLayoutRequest::~UiSetDisplayLayoutRequest() { +} + +void UiSetDisplayLayoutRequest::Run() { + LOG4CXX_INFO(logger_, "UiSetDisplayLayoutRequest::Run"); + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_set_display_layout_response.cc b/src/components/application_manager/src/commands/hmi/ui_set_display_layout_response.cc new file mode 100644 index 0000000000..f381a4db28 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_display_layout_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_display_layout_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UiSetDisplayLayoutResponse::UiSetDisplayLayoutResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +UiSetDisplayLayoutResponse::~UiSetDisplayLayoutResponse() { +} + +void UiSetDisplayLayoutResponse::Run() { + LOG4CXX_INFO(logger_, "UiSetDisplayLayoutResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_SetDisplayLayout); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_set_global_properties_request.cc b/src/components/application_manager/src/commands/hmi/ui_set_global_properties_request.cc new file mode 100644 index 0000000000..e538866c1b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_global_properties_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_global_properties_request.h" + +namespace application_manager { + +namespace commands { + +UISetGlobalPropertiesRequest::UISetGlobalPropertiesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UISetGlobalPropertiesRequest::~UISetGlobalPropertiesRequest() { +} + +void UISetGlobalPropertiesRequest::Run() { + LOG4CXX_INFO(logger_, "UISetGlobalPropertiesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_set_global_properties_response.cc b/src/components/application_manager/src/commands/hmi/ui_set_global_properties_response.cc new file mode 100644 index 0000000000..67023533c9 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_global_properties_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_global_properties_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UISetGlobalPropertiesResponse::UISetGlobalPropertiesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UISetGlobalPropertiesResponse::~UISetGlobalPropertiesResponse() { +} + +void UISetGlobalPropertiesResponse::Run() { + LOG4CXX_INFO(logger_, "UISetGlobalPropertiesResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_SetGlobalProperties); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_set_icon_request.cc b/src/components/application_manager/src/commands/hmi/ui_set_icon_request.cc new file mode 100644 index 0000000000..b587a3028e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_icon_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_icon_request.h" + +namespace application_manager { + +namespace commands { + +UISetIconRequest::UISetIconRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UISetIconRequest::~UISetIconRequest() { +} + +void UISetIconRequest::Run() { + LOG4CXX_INFO(logger_, "UISetIconRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_set_icon_response.cc b/src/components/application_manager/src/commands/hmi/ui_set_icon_response.cc new file mode 100644 index 0000000000..f4565baaf1 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_icon_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_icon_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UISetIconResponse::UISetIconResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UISetIconResponse::~UISetIconResponse() { +} + +void UISetIconResponse::Run() { + LOG4CXX_INFO(logger_, "UISetIconResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_SetAppIcon); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_set_media_clock_timer_request.cc b/src/components/application_manager/src/commands/hmi/ui_set_media_clock_timer_request.cc new file mode 100644 index 0000000000..1eb218013b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_media_clock_timer_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_media_clock_timer_request.h" + +namespace application_manager { + +namespace commands { + +UISetMediaClockTimerRequest::UISetMediaClockTimerRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UISetMediaClockTimerRequest::~UISetMediaClockTimerRequest() { +} + +void UISetMediaClockTimerRequest::Run() { + LOG4CXX_INFO(logger_, "UISetMediaClockTimerRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_set_media_clock_timer_response.cc b/src/components/application_manager/src/commands/hmi/ui_set_media_clock_timer_response.cc new file mode 100644 index 0000000000..ee67862a1a --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_set_media_clock_timer_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_set_media_clock_timer_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UISetMediaClockTimerResponse::UISetMediaClockTimerResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UISetMediaClockTimerResponse::~UISetMediaClockTimerResponse() { +} + +void UISetMediaClockTimerResponse::Run() { + LOG4CXX_INFO(logger_, "UISetMediaClockTimerResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_SetMediaClockTimer); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_show_request.cc b/src/components/application_manager/src/commands/hmi/ui_show_request.cc new file mode 100644 index 0000000000..841c8a62fa --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_show_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_show_request.h" + +namespace application_manager { + +namespace commands { + +UIShowRequest::UIShowRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UIShowRequest::~UIShowRequest() { +} + +void UIShowRequest::Run() { + LOG4CXX_INFO(logger_, "UIShowRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_show_response.cc b/src/components/application_manager/src/commands/hmi/ui_show_response.cc new file mode 100644 index 0000000000..c95cbbd2ba --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_show_response.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_show_response.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +UIShowResponse::UIShowResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UIShowResponse::~UIShowResponse() { +} + +void UIShowResponse::Run() { + LOG4CXX_INFO(logger_, "UIShowResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_Show); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/ui_slider_request.cc b/src/components/application_manager/src/commands/hmi/ui_slider_request.cc new file mode 100644 index 0000000000..fc7203c0ea --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_slider_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_slider_request.h" + +namespace application_manager { + +namespace commands { + +UISliderRequest::UISliderRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UISliderRequest::~UISliderRequest() { +} + +void UISliderRequest::Run() { + LOG4CXX_INFO(logger_, "UISliderRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/ui_slider_response.cc b/src/components/application_manager/src/commands/hmi/ui_slider_response.cc new file mode 100644 index 0000000000..8d2522e224 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/ui_slider_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/ui_slider_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UISliderResponse::UISliderResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UISliderResponse::~UISliderResponse() { +} + +void UISliderResponse::Run() { + LOG4CXX_INFO(logger_, "UISliderResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::UI_Slider); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/update_app_list_request.cc b/src/components/application_manager/src/commands/hmi/update_app_list_request.cc new file mode 100644 index 0000000000..955f4b19c6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/update_app_list_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/update_app_list_request.h" + +namespace application_manager { + +namespace commands { + +UpdateAppListRequest::UpdateAppListRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UpdateAppListRequest::~UpdateAppListRequest() { +} + +void UpdateAppListRequest::Run() { + LOG4CXX_INFO(logger_, "UpdateAppListRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/update_app_list_response.cc b/src/components/application_manager/src/commands/hmi/update_app_list_response.cc new file mode 100644 index 0000000000..d5db0b4ea8 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/update_app_list_response.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/update_app_list_response.h" + +namespace application_manager { + +namespace commands { + +UpdateAppListResponse::UpdateAppListResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UpdateAppListResponse::~UpdateAppListResponse() { +} + +void UpdateAppListResponse::Run() { + LOG4CXX_INFO(logger_, "UpdateAppListResponse::Run"); + + // TODO(PV): add check +} + +} // namespace commands + +} // namespace application_manager + + diff --git a/src/components/application_manager/src/commands/hmi/update_device_list_request.cc b/src/components/application_manager/src/commands/hmi/update_device_list_request.cc new file mode 100644 index 0000000000..1f632378b4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/update_device_list_request.cc @@ -0,0 +1,96 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/update_device_list_request.h" +#include "application_manager/application_manager_impl.h" +#include "config_profile/profile.h" +#include "interfaces/HMI_API.h" + +#include <unistd.h> + +namespace application_manager { + +namespace commands { + +UpdateDeviceListRequest::UpdateDeviceListRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UpdateDeviceListRequest::~UpdateDeviceListRequest() { +} + +void UpdateDeviceListRequest::Run() { + LOG4CXX_INFO(logger_, "UpdateDeviceListRequest::Run"); + sync_primitives::AutoLock auto_lock(wait_hmi_lock); + // Fix problem with SDL and HMI HTML. This problem is not actual for HMI PASA. + // Flag conditional compilation "CUSTOMER_PASA" is used in order to exclude + // hit code to RTC + if (true == profile::Profile::instance()->launch_hmi()) { + if (!ApplicationManagerImpl::instance()->IsHMICooperating()) { + LOG4CXX_INFO(logger_, "MY Wait for HMI Cooperation"); + subscribe_on_event(hmi_apis::FunctionID::BasicCommunication_OnReady); + termination_condition_.Wait(auto_lock); + LOG4CXX_INFO(logger_, "MY HMI Cooperation OK"); + } + } + + SendRequest(); +} + +void UpdateDeviceListRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "UpdateDeviceListRequest::on_event"); + sync_primitives::AutoLock auto_lock(wait_hmi_lock); + switch (event.id()) { + case hmi_apis::FunctionID::BasicCommunication_OnReady : { + LOG4CXX_INFO(logger_, "received OnReady"); + unsubscribe_from_event(hmi_apis::FunctionID::BasicCommunication_OnReady); + termination_condition_.Broadcast(); + break; + }; + default : { + LOG4CXX_ERROR(logger_, "Unknown event "); + break; + }; + } +} + +bool UpdateDeviceListRequest::CleanUp() { + sync_primitives::AutoLock auto_lock(wait_hmi_lock); + termination_condition_.Broadcast(); + return true; +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/update_device_list_response.cc b/src/components/application_manager/src/commands/hmi/update_device_list_response.cc new file mode 100644 index 0000000000..85ef57404c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/update_device_list_response.cc @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/update_device_list_response.h" + +namespace application_manager { + +namespace commands { + +UpdateDeviceListResponse::UpdateDeviceListResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +UpdateDeviceListResponse::~UpdateDeviceListResponse() { +} + +void UpdateDeviceListResponse::Run() { + LOG4CXX_INFO(logger_, "UpdateDeviceListResponse::Run"); + + // TODO(PV): add check for correctness. +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/update_sdl_request.cc b/src/components/application_manager/src/commands/hmi/update_sdl_request.cc new file mode 100644 index 0000000000..7d47f84ce3 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/update_sdl_request.cc @@ -0,0 +1,58 @@ + +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/update_sdl_request.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +UpdateSDLRequest::UpdateSDLRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +UpdateSDLRequest::~UpdateSDLRequest() { +} + +void UpdateSDLRequest::Run() { + LOG4CXX_INFO(logger_, "UpdateSDLRequest::Run"); + + policy::PolicyHandler::instance()->PTExchangeAtUserRequest( + (*message_)[strings::params][strings::correlation_id].asInt()); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/update_sdl_response.cc b/src/components/application_manager/src/commands/hmi/update_sdl_response.cc new file mode 100644 index 0000000000..d2be2c655c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/update_sdl_response.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/update_sdl_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +UpdateSDLResponse::UpdateSDLResponse( + const MessageSharedPtr& message): ResponseFromHMI(message) { +} + +UpdateSDLResponse::~UpdateSDLResponse() { +} + +void UpdateSDLResponse::Run() { + LOG4CXX_INFO(logger_, "UpdateSDLResponse::Run"); + (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_; + (*message_)[strings::params][strings::protocol_version] = protocol_version_; + + ApplicationManagerImpl::instance()->SendMessageToHMI(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_diagnostic_message_request.cc b/src/components/application_manager/src/commands/hmi/vi_diagnostic_message_request.cc new file mode 100644 index 0000000000..45d44e4475 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_diagnostic_message_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_diagnostic_message_request.h" + +namespace application_manager { + +namespace commands { + +VIDiagnosticMessageRequest::VIDiagnosticMessageRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIDiagnosticMessageRequest::~VIDiagnosticMessageRequest() { +} + +void VIDiagnosticMessageRequest::Run() { + LOG4CXX_INFO(logger_, "VIDiagnosticMessageRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_diagnostic_message_response.cc b/src/components/application_manager/src/commands/hmi/vi_diagnostic_message_response.cc new file mode 100644 index 0000000000..d83869b279 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_diagnostic_message_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_diagnostic_message_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VIDiagnosticMessageResponse::VIDiagnosticMessageResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIDiagnosticMessageResponse::~VIDiagnosticMessageResponse() { +} + +void VIDiagnosticMessageResponse::Run() { + LOG4CXX_INFO(logger_, "VIDiagnosticMessageResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::VehicleInfo_DiagnosticMessage); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_get_dtcs_request.cc b/src/components/application_manager/src/commands/hmi/vi_get_dtcs_request.cc new file mode 100644 index 0000000000..5289816fb5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_get_dtcs_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_get_dtcs_request.h" + +namespace application_manager { + +namespace commands { + +VIGetDTCsRequest::VIGetDTCsRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIGetDTCsRequest::~VIGetDTCsRequest() { +} + +void VIGetDTCsRequest::Run() { + LOG4CXX_INFO(logger_, "VIGetDTCsRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_get_dtcs_response.cc b/src/components/application_manager/src/commands/hmi/vi_get_dtcs_response.cc new file mode 100644 index 0000000000..0cacc51d6c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_get_dtcs_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_get_dtcs_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VIGetDTCsResponse::VIGetDTCsResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIGetDTCsResponse::~VIGetDTCsResponse() { +} + +void VIGetDTCsResponse::Run() { + LOG4CXX_INFO(logger_, "VIGetDTCsResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::VehicleInfo_GetDTCs); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_request.cc b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_request.cc new file mode 100644 index 0000000000..40b2ca9fed --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_get_vehicle_data_request.h" + +namespace application_manager { + +namespace commands { + +VIGetVehicleDataRequest::VIGetVehicleDataRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIGetVehicleDataRequest::~VIGetVehicleDataRequest() { +} + +void VIGetVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "VIGetVehicleDataRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc new file mode 100644 index 0000000000..73444a19bd --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_data_response.cc @@ -0,0 +1,95 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_get_vehicle_data_response.h" +#include "application_manager/event_engine/event.h" +#include "application_manager/policies/policy_handler.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VIGetVehicleDataResponse::VIGetVehicleDataResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIGetVehicleDataResponse::~VIGetVehicleDataResponse() { +} + +void VIGetVehicleDataResponse::Run() { + LOG4CXX_INFO(logger_, "VIGetVehicleDataResponse::Run"); + smart_objects::SmartObject* result_so = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!result_so) { + // TODO(PV): add response with out of memory. + LOG4CXX_ERROR(logger_, + "Failed to create new Smart Object on get vehicle response."); + return; + } + + event_engine::Event event(hmi_apis::FunctionID::VehicleInfo_GetVehicleData); + + smart_objects::SmartObject& result = *result_so; + + if ((*message_)[strings::params][strings::message_type] + == static_cast<int32_t>(hmi_apis::messageType::error_response)) { + if ((*message_)[strings::params].keyExists(strings::data)) { + result[strings::msg_params] = (*message_)[strings::params][strings::data]; + result[strings::params][hmi_response::code] = + (*message_)[strings::params][hmi_response::code]; + result[strings::params][strings::correlation_id] = + (*message_)[strings::params][strings::correlation_id]; + result[strings::params][strings::error_msg] = + (*message_)[strings::params][strings::error_msg]; + result[strings::params][strings::message_type] = + (*message_)[strings::params][strings::message_type]; + result[strings::params][strings::protocol_type] = + (*message_)[strings::params][strings::protocol_type]; + result[strings::params][strings::protocol_version] = + (*message_)[strings::params][strings::protocol_version]; + } + + + event.set_smart_object(*result_so); + } else { + event.set_smart_object(*message_); + policy::PolicyHandler::instance()->OnVehicleDataUpdated(*message_); + } + + + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_get_vehicle_type_request.cc b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_type_request.cc new file mode 100644 index 0000000000..4c46de950e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_type_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_get_vehicle_type_request.h" + +namespace application_manager { + +namespace commands { + +VIGetVehicleTypeRequest::VIGetVehicleTypeRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIGetVehicleTypeRequest::~VIGetVehicleTypeRequest() { +} + +void VIGetVehicleTypeRequest::Run() { + LOG4CXX_INFO(logger_, "VIGetVehicleTypeRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_get_vehicle_type_response.cc b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_type_response.cc new file mode 100644 index 0000000000..18c0136d12 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_get_vehicle_type_response.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_get_vehicle_type_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +VIGetVehicleTypeResponse::VIGetVehicleTypeResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIGetVehicleTypeResponse::~VIGetVehicleTypeResponse() { +} + +void VIGetVehicleTypeResponse::Run() { + LOG4CXX_INFO(logger_, "VIGetVehicleTypeResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_vehicle_type( + (*message_)[strings::msg_params][hmi_response::vehicle_type]); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_is_ready_request.cc b/src/components/application_manager/src/commands/hmi/vi_is_ready_request.cc new file mode 100644 index 0000000000..074d6f6022 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_is_ready_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_is_ready_request.h" + +namespace application_manager { + +namespace commands { + +VIIsReadyRequest::VIIsReadyRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIIsReadyRequest::~VIIsReadyRequest() { +} + +void VIIsReadyRequest::Run() { + LOG4CXX_INFO(logger_, "VIIsReadyRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc b/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc new file mode 100644 index 0000000000..e7c9c180c2 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_is_ready_response.cc @@ -0,0 +1,65 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_is_ready_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +namespace commands { + +VIIsReadyResponse::VIIsReadyResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIIsReadyResponse::~VIIsReadyResponse() { +} + +void VIIsReadyResponse::Run() { + LOG4CXX_INFO(logger_, "VIIsReadyResponse::Run"); + smart_objects::SmartObject& object = *message_; + + bool is_available = false; + if (object[strings::msg_params].keyExists(strings::available)) { + is_available = object[strings::msg_params][strings::available].asBool(); + } + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + hmi_capabilities.set_is_ivi_cooperating(is_available); + + policy::PolicyHandler::instance()->OnVIIsReady(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_read_did_request.cc b/src/components/application_manager/src/commands/hmi/vi_read_did_request.cc new file mode 100644 index 0000000000..1485b471c4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_read_did_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_read_did_request.h" + +namespace application_manager { + +namespace commands { + +VIReadDIDRequest::VIReadDIDRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIReadDIDRequest::~VIReadDIDRequest() { +} + +void VIReadDIDRequest::Run() { + LOG4CXX_INFO(logger_, "VIReadDIDRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_read_did_response.cc b/src/components/application_manager/src/commands/hmi/vi_read_did_response.cc new file mode 100644 index 0000000000..ddd9f3c540 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_read_did_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_read_did_response.h" +#include "application_manager/event_engine/event.h" +#include "application_manager/application_manager_impl.h" + + +namespace application_manager { + +namespace commands { + +VIReadDIDResponse::VIReadDIDResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIReadDIDResponse::~VIReadDIDResponse() { +} + +void VIReadDIDResponse::Run() { + LOG4CXX_INFO(logger_, "VIReadDIDResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::VehicleInfo_ReadDID); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_subscribe_vehicle_data_request.cc b/src/components/application_manager/src/commands/hmi/vi_subscribe_vehicle_data_request.cc new file mode 100644 index 0000000000..38950a2a2b --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_subscribe_vehicle_data_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_subscribe_vehicle_data_request.h" + +namespace application_manager { + +namespace commands { + +VISubscribeVehicleDataRequest::VISubscribeVehicleDataRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VISubscribeVehicleDataRequest::~VISubscribeVehicleDataRequest() { +} + +void VISubscribeVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "VISubscribeVehicleDataRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_subscribe_vehicle_data_response.cc b/src/components/application_manager/src/commands/hmi/vi_subscribe_vehicle_data_response.cc new file mode 100644 index 0000000000..bd67294fbb --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_subscribe_vehicle_data_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_subscribe_vehicle_data_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { +namespace commands { + +VISubscribeVehicleDataResponse::VISubscribeVehicleDataResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VISubscribeVehicleDataResponse::~VISubscribeVehicleDataResponse() { +} + +void VISubscribeVehicleDataResponse::Run() { + LOG4CXX_INFO(logger_, "VISubscribeVehicleDataResponse::Run"); + event_engine::Event event( + hmi_apis::FunctionID::VehicleInfo_SubscribeVehicleData + ); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vi_unsubscribe_vehicle_data_request.cc b/src/components/application_manager/src/commands/hmi/vi_unsubscribe_vehicle_data_request.cc new file mode 100644 index 0000000000..0af87c2a2e --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_unsubscribe_vehicle_data_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_unsubscribe_vehicle_data_request.h" + +namespace application_manager { + +namespace commands { + +VIUnsubscribeVehicleDataRequest::VIUnsubscribeVehicleDataRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VIUnsubscribeVehicleDataRequest::~VIUnsubscribeVehicleDataRequest() { +} + +void VIUnsubscribeVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "VIUnsubscribeVehicleDataRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vi_unsubscribe_vehicle_data_response.cc b/src/components/application_manager/src/commands/hmi/vi_unsubscribe_vehicle_data_response.cc new file mode 100644 index 0000000000..22231b4a61 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vi_unsubscribe_vehicle_data_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vi_unsubscribe_vehicle_data_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { +namespace commands { + +VIUnsubscribeVehicleDataResponse::VIUnsubscribeVehicleDataResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VIUnsubscribeVehicleDataResponse::~VIUnsubscribeVehicleDataResponse() { +} + +void VIUnsubscribeVehicleDataResponse::Run() { + LOG4CXX_INFO(logger_, "VIUnsubscribeVehicleDataResponse::Run"); + event_engine::Event event( + hmi_apis::FunctionID::VehicleInfo_UnsubscribeVehicleData + ); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_add_command_request.cc b/src/components/application_manager/src/commands/hmi/vr_add_command_request.cc new file mode 100644 index 0000000000..a74ece95da --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_add_command_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_add_command_request.h" + +namespace application_manager { + +namespace commands { + +VRAddCommandRequest::VRAddCommandRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRAddCommandRequest::~VRAddCommandRequest() { +} + +void VRAddCommandRequest::Run() { + LOG4CXX_INFO(logger_, "VRAddCommandRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_add_command_response.cc b/src/components/application_manager/src/commands/hmi/vr_add_command_response.cc new file mode 100644 index 0000000000..513ccdace2 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_add_command_response.cc @@ -0,0 +1,57 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_add_command_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VRAddCommandResponse::VRAddCommandResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRAddCommandResponse::~VRAddCommandResponse() { +} + +void VRAddCommandResponse::Run() { + LOG4CXX_INFO(logger_, "VRAddCommandResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::VR_AddCommand); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_change_registration_request.cc b/src/components/application_manager/src/commands/hmi/vr_change_registration_request.cc new file mode 100644 index 0000000000..bd7c1e7841 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_change_registration_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_change_registration_request.h" + +namespace application_manager { + +namespace commands { + +VRChangeRegistrationRequest::VRChangeRegistrationRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRChangeRegistrationRequest::~VRChangeRegistrationRequest() { +} + +void VRChangeRegistrationRequest::Run() { + LOG4CXX_INFO(logger_, "VRChangeRegistrationRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_change_registration_response.cc b/src/components/application_manager/src/commands/hmi/vr_change_registration_response.cc new file mode 100644 index 0000000000..92a36d23f6 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_change_registration_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_change_registration_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VRChangeRegistrationResponse::VRChangeRegistrationResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRChangeRegistrationResponse::~VRChangeRegistrationResponse() { +} + +void VRChangeRegistrationResponse::Run() { + LOG4CXX_INFO(logger_, "VRChangeRegistratioResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::VR_ChangeRegistration); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_delete_command_request.cc b/src/components/application_manager/src/commands/hmi/vr_delete_command_request.cc new file mode 100644 index 0000000000..0241be6308 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_delete_command_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_delete_command_request.h" + +namespace application_manager { + +namespace commands { + +VRDeleteCommandRequest::VRDeleteCommandRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRDeleteCommandRequest::~VRDeleteCommandRequest() { +} + +void VRDeleteCommandRequest::Run() { + LOG4CXX_INFO(logger_, "VRDeleteCommandRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_delete_command_response.cc b/src/components/application_manager/src/commands/hmi/vr_delete_command_response.cc new file mode 100644 index 0000000000..c5a13126b0 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_delete_command_response.cc @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_delete_command_response.h" +#include "application_manager/event_engine/event.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VRDeleteCommandResponse::VRDeleteCommandResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRDeleteCommandResponse::~VRDeleteCommandResponse() { +} + +void VRDeleteCommandResponse::Run() { + LOG4CXX_INFO(logger_, "VRDeleteCommandResponse::Run"); + + event_engine::Event event(hmi_apis::FunctionID::VR_DeleteCommand); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_get_capabilities_request.cc b/src/components/application_manager/src/commands/hmi/vr_get_capabilities_request.cc new file mode 100644 index 0000000000..8b1d4ae0b4 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_get_capabilities_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_get_capabilities_request.h" + +namespace application_manager { + +namespace commands { + +VRGetCapabilitiesRequest::VRGetCapabilitiesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRGetCapabilitiesRequest::~VRGetCapabilitiesRequest() { +} + +void VRGetCapabilitiesRequest::Run() { + LOG4CXX_INFO(logger_, "VRGetCapabilitiesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_get_capabilities_response.cc b/src/components/application_manager/src/commands/hmi/vr_get_capabilities_response.cc new file mode 100644 index 0000000000..de6fdd7a93 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_get_capabilities_response.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_get_capabilities_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +VRGetCapabilitiesResponse::VRGetCapabilitiesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRGetCapabilitiesResponse::~VRGetCapabilitiesResponse() { +} + +void VRGetCapabilitiesResponse::Run() { + LOG4CXX_INFO(logger_, "VRGetCapabilitiesResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + hmi_capabilities.set_vr_capabilities( + (*message_)[strings::msg_params][strings::vr_capabilities]); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_get_language_request.cc b/src/components/application_manager/src/commands/hmi/vr_get_language_request.cc new file mode 100644 index 0000000000..9f4aeb9797 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_get_language_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_get_language_request.h" + +namespace application_manager { + +namespace commands { + +VRGetLanguageRequest::VRGetLanguageRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRGetLanguageRequest::~VRGetLanguageRequest() { +} + +void VRGetLanguageRequest::Run() { + LOG4CXX_INFO(logger_, "VRGetLanguageRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_get_language_response.cc b/src/components/application_manager/src/commands/hmi/vr_get_language_response.cc new file mode 100644 index 0000000000..acbd24fbbf --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_get_language_response.cc @@ -0,0 +1,59 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_get_language_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VRGetLanguageResponse::VRGetLanguageResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRGetLanguageResponse::~VRGetLanguageResponse() { +} + +void VRGetLanguageResponse::Run() { + LOG4CXX_INFO(logger_, "VRGetLanguageResponse::Run"); + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + hmi_capabilities.set_active_vr_language( + static_cast<hmi_apis::Common_Language::eType>( + (*message_)[strings::msg_params][hmi_response::language].asInt())); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_get_supported_languages_request.cc b/src/components/application_manager/src/commands/hmi/vr_get_supported_languages_request.cc new file mode 100644 index 0000000000..e43d88430d --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_get_supported_languages_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_get_supported_languages_request.h" + +namespace application_manager { + +namespace commands { + +VRGetSupportedLanguagesRequest::VRGetSupportedLanguagesRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRGetSupportedLanguagesRequest::~VRGetSupportedLanguagesRequest() { +} + +void VRGetSupportedLanguagesRequest::Run() { + LOG4CXX_INFO(logger_, "VRGetSupportedLanguagesRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_get_supported_languages_response.cc b/src/components/application_manager/src/commands/hmi/vr_get_supported_languages_response.cc new file mode 100644 index 0000000000..d2cc148a09 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_get_supported_languages_response.cc @@ -0,0 +1,66 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_get_supported_languages_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +VRGetSupportedLanguagesResponse::VRGetSupportedLanguagesResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRGetSupportedLanguagesResponse::~VRGetSupportedLanguagesResponse() { +} + +void VRGetSupportedLanguagesResponse::Run() { + LOG4CXX_INFO(logger_, "VRGetSupportedLanguagesResponse::Run"); + + const hmi_apis::Common_Result::eType code = + static_cast<hmi_apis::Common_Result::eType>( + (*message_)[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS == code) { + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + hmi_capabilities.set_vr_supported_languages( + (*message_)[strings::msg_params][hmi_response::languages]); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_is_ready_request.cc b/src/components/application_manager/src/commands/hmi/vr_is_ready_request.cc new file mode 100644 index 0000000000..944cfcbb3c --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_is_ready_request.cc @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_is_ready_request.h" + +namespace application_manager { + +namespace commands { + +VRIsReadyRequest::VRIsReadyRequest(const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRIsReadyRequest::~VRIsReadyRequest() { +} + +void VRIsReadyRequest::Run() { + LOG4CXX_INFO(logger_, "VRIsReadyRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_is_ready_response.cc b/src/components/application_manager/src/commands/hmi/vr_is_ready_response.cc new file mode 100644 index 0000000000..8cf5e66ee7 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_is_ready_response.cc @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_is_ready_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +VRIsReadyResponse::VRIsReadyResponse(const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRIsReadyResponse::~VRIsReadyResponse() { +} + +void VRIsReadyResponse::Run() { + LOG4CXX_INFO(logger_, "VRIsReadyResponse::Run"); + smart_objects::SmartObject& object = *message_; + + bool is_available = false; + if (object[strings::msg_params].keyExists(strings::available)) { + is_available = object[strings::msg_params][strings::available].asBool(); + } + + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + hmi_capabilities.set_is_vr_cooperating(is_available); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/hmi/vr_perform_interaction_request.cc b/src/components/application_manager/src/commands/hmi/vr_perform_interaction_request.cc new file mode 100644 index 0000000000..6de32dc5b5 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_perform_interaction_request.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_perform_interaction_request.h" + +namespace application_manager { + +namespace commands { + +VRPerformInteractionRequest::VRPerformInteractionRequest( + const MessageSharedPtr& message) + : RequestToHMI(message) { +} + +VRPerformInteractionRequest::~VRPerformInteractionRequest() { +} + +void VRPerformInteractionRequest::Run() { + LOG4CXX_INFO(logger_, "VRPerformInteractionRequest::Run"); + + SendRequest(); +} + +} // namespace commands + +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/hmi/vr_perform_interaction_response.cc b/src/components/application_manager/src/commands/hmi/vr_perform_interaction_response.cc new file mode 100644 index 0000000000..fea09b9f29 --- /dev/null +++ b/src/components/application_manager/src/commands/hmi/vr_perform_interaction_response.cc @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/commands/hmi/vr_perform_interaction_response.h" +#include "application_manager/event_engine/event.h" + +namespace application_manager { + +namespace commands { + +VRPerformInteractionResponse::VRPerformInteractionResponse( + const MessageSharedPtr& message) + : ResponseFromHMI(message) { +} + +VRPerformInteractionResponse::~VRPerformInteractionResponse() { +} + +void VRPerformInteractionResponse::Run() { + LOG4CXX_INFO(logger_, "VRPerformInteractionResponse::Run"); + event_engine::Event event(hmi_apis::FunctionID::VR_PerformInteraction); + event.set_smart_object(*message_); + event.raise(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/add_command_request.cc b/src/components/application_manager/src/commands/mobile/add_command_request.cc new file mode 100644 index 0000000000..35cc619895 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/add_command_request.cc @@ -0,0 +1,414 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string> +#include "application_manager/commands/mobile/add_command_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application.h" +#include "application_manager/message_helper.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +AddCommandRequest::AddCommandRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message), + send_ui_(false), + send_vr_(false), + is_ui_received_(false), + is_vr_received_(false), + ui_result_(hmi_apis::Common_Result::INVALID_ENUM), + vr_result_(hmi_apis::Common_Result::INVALID_ENUM) { +} + +AddCommandRequest::~AddCommandRequest() { +} + +void AddCommandRequest::onTimeOut() { + LOG4CXX_INFO(logger_, "AddCommandRequest::onTimeOut"); + RemoveCommand(); + CommandRequestImpl::onTimeOut(); +} + +void AddCommandRequest::Run() { + LOG4CXX_INFO(logger_, "AddCommandRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "No application associated with session key"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if ((*message_)[strings::msg_params].keyExists(strings::cmd_icon)) { + mobile_apis::Result::eType verification_result = + MessageHelper::VerifyImage((*message_)[strings::msg_params] + [strings::cmd_icon], app); + + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR_EXT( + logger_, + "MessageHelper::VerifyImage return " << verification_result); + SendResponse(false, verification_result); + return; + } + } + + if (!((*message_)[strings::msg_params].keyExists(strings::cmd_id))) { + LOG4CXX_ERROR_EXT(logger_, "INVALID_DATA"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if (app->FindCommand( + (*message_)[strings::msg_params][strings::cmd_id].asUInt())) { + LOG4CXX_ERROR_EXT(logger_, "INVALID_ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return; + } + + bool data_exist = false; + + if ((*message_)[strings::msg_params].keyExists(strings::menu_params)) { + if (!CheckCommandName(app)) { + SendResponse(false, mobile_apis::Result::DUPLICATE_NAME); + return; + } + if (((*message_)[strings::msg_params][strings::menu_params].keyExists( + hmi_request::parent_id)) && (0 != (*message_)[strings::msg_params] + [strings::menu_params][hmi_request::parent_id].asUInt())) { + if (!CheckCommandParentId(app)) { + SendResponse(false, mobile_apis::Result::INVALID_ID, + "Parent ID doesn't exist"); + return; + } + } + data_exist = true; + } + + if (((*message_)[strings::msg_params].keyExists(strings::vr_commands)) + && ((*message_)[strings::msg_params] + [strings::vr_commands].length() > 0)) { + + if (!CheckCommandVRSynonym(app)) { + SendResponse(false, mobile_apis::Result::DUPLICATE_NAME); + return; + } + + data_exist = true; + } + + if (!data_exist) { + LOG4CXX_ERROR_EXT(logger_, "INVALID_DATA"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming add command has contains \t\n \\t \\n"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + app->AddCommand((*message_)[strings::msg_params] + [strings::cmd_id].asUInt(), + (*message_)[strings::msg_params]); + + smart_objects::SmartObject ui_msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + if ((*message_)[strings::msg_params].keyExists(strings::menu_params)) { + ui_msg_params[strings::cmd_id] = + (*message_)[strings::msg_params][strings::cmd_id]; + ui_msg_params[strings::menu_params] = + (*message_)[strings::msg_params][strings::menu_params]; + + ui_msg_params[strings::app_id] = app->app_id(); + + if ( ((*message_)[strings::msg_params].keyExists(strings::cmd_icon)) + && ((*message_)[strings::msg_params][strings::cmd_icon].keyExists(strings::value)) + && (0 < (*message_)[strings::msg_params][strings::cmd_icon] + [strings::value].length())) { + ui_msg_params[strings::cmd_icon] = + (*message_)[strings::msg_params][strings::cmd_icon]; + } + + send_ui_ = true; + } + + smart_objects::SmartObject vr_msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + if ((*message_)[strings::msg_params].keyExists(strings::vr_commands)) { + vr_msg_params[strings::cmd_id] = + (*message_)[strings::msg_params][strings::cmd_id]; + vr_msg_params[strings::vr_commands] = + (*message_)[strings::msg_params][strings::vr_commands]; + vr_msg_params[strings::app_id] = app->app_id(); + + vr_msg_params[strings::type] = hmi_apis::Common_VRCommandType::Command; + vr_msg_params[strings::grammar_id] = app->get_grammar_id(); + + send_vr_ = true; + } + + if (send_ui_) { + SendHMIRequest(hmi_apis::FunctionID::UI_AddCommand, &ui_msg_params, true); + } + + if (send_vr_) { + SendHMIRequest(hmi_apis::FunctionID::VR_AddCommand, &vr_msg_params, true); + } +} + +bool AddCommandRequest::CheckCommandName(ApplicationConstSharedPtr app) { + if (!app) { + return false; + } + + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator i = commands.begin(); + uint32_t saved_parent_id = 0; + uint32_t parent_id = 0; + if ((*message_)[strings::msg_params] + [strings::menu_params].keyExists(hmi_request::parent_id)) { + parent_id = (*message_)[strings::msg_params] + [strings::menu_params][hmi_request::parent_id].asUInt(); + } + + for (; commands.end() != i; ++i) { + + if (!(*i->second).keyExists(strings::menu_params)) { + continue; + } + + saved_parent_id = 0; + if ((*i->second)[strings::menu_params].keyExists(hmi_request::parent_id)) { + saved_parent_id = (*i->second)[strings::menu_params][hmi_request::parent_id].asUInt(); + } + if (((*i->second)[strings::menu_params][strings::menu_name].asString() + == (*message_)[strings::msg_params][strings::menu_params] + [strings::menu_name].asString()) && + (saved_parent_id == parent_id)) { + LOG4CXX_INFO(logger_, "AddCommandRequest::CheckCommandName received" + " command name already exist in same level menu"); + return false; + } + } + return true; +} + +bool AddCommandRequest::CheckCommandVRSynonym(ApplicationConstSharedPtr app) { + if (!app) { + return false; + } + + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator it = commands.begin(); + + for (; commands.end() != it; ++it) { + + if(!(*it->second).keyExists(strings::vr_commands)) { + continue; + } + + for (size_t i = 0; i < (*it->second)[strings::vr_commands].length(); ++i) { + for (size_t j = 0; + j < (*message_)[strings::msg_params][strings::vr_commands].length(); + ++j) { + std::string vr_cmd_i = + (*it->second)[strings::vr_commands][i].asString(); + std::string vr_cmd_j = + (*message_)[strings::msg_params] + [strings::vr_commands][j].asString(); + + if (0 == strcasecmp(vr_cmd_i.c_str(), vr_cmd_j.c_str())) { + LOG4CXX_INFO(logger_, "AddCommandRequest::CheckCommandVRSynonym" + " received command vr synonym already exist"); + return false; + } + } + } + } + return true; +} + +bool AddCommandRequest::CheckCommandParentId(ApplicationConstSharedPtr app) { + if (!app) { + return false; + } + + const int32_t parent_id = + (*message_)[strings::msg_params][strings::menu_params] + [hmi_request::parent_id].asInt(); + smart_objects::SmartObject* parent = app->FindSubMenu(parent_id); + + if (!parent) { + LOG4CXX_INFO(logger_, "AddCommandRequest::CheckCommandParentId received" + " submenu doesn't exist"); + return false; + } + return true; +} + +void AddCommandRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "AddCommandRequest::on_event"); + + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_AddCommand: { + LOG4CXX_INFO(logger_, "Received UI_AddCommand event"); + is_ui_received_ = true; + ui_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS != ui_result_) { + (*message_)[strings::msg_params].erase(strings::menu_params); + } + break; + } + case hmi_apis::FunctionID::VR_AddCommand: { + LOG4CXX_INFO(logger_, "Received VR_AddCommand event"); + is_vr_received_ = true; + vr_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + if (hmi_apis::Common_Result::SUCCESS != vr_result_) { + (*message_)[strings::msg_params].erase(strings::vr_commands); + } + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + return; + } + } + + if (!IsPendingResponseExist()) { + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + if (hmi_apis::Common_Result::REJECTED == ui_result_) { + RemoveCommand(); + } + + mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM; + + bool result = ((hmi_apis::Common_Result::SUCCESS == ui_result_) && + (hmi_apis::Common_Result::SUCCESS == vr_result_)) || + ((hmi_apis::Common_Result::SUCCESS == ui_result_) && + (hmi_apis::Common_Result::INVALID_ENUM == vr_result_ || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == vr_result_)) || + ((hmi_apis::Common_Result::INVALID_ENUM == ui_result_ || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == ui_result_ ) && + (hmi_apis::Common_Result::SUCCESS == vr_result_)); + + if (!result && (hmi_apis::Common_Result::REJECTED == ui_result_)) { + result_code = static_cast<mobile_apis::Result::eType>(ui_result_); + } else { + result_code = static_cast<mobile_apis::Result::eType>( + std::max(ui_result_, vr_result_)); + } + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + if (true == result) { + application->UpdateHash(); + } + } +} + +bool AddCommandRequest::IsPendingResponseExist() { + return send_ui_ != is_ui_received_ || send_vr_ != is_vr_received_; +} + +bool AddCommandRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "AddCommandRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::menu_params)) { + str = (*message_)[strings::msg_params][strings::menu_params] + [strings::menu_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid menu name syntax check failed."); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::vr_commands)) { + const size_t len = + (*message_)[strings::msg_params][strings::vr_commands].length(); + + for (size_t i = 0; i < len; ++i) { + str = (*message_)[strings::msg_params] + [strings::vr_commands][i].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_commands syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::cmd_icon)) { + str = (*message_)[strings::msg_params] + [strings::cmd_icon][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid cmd_icon value syntax check failed"); + return true; + } + } + return false; +} + +void AddCommandRequest::RemoveCommand() { + LOG4CXX_INFO(logger_, "AddCommandRequest::RemoveCommand"); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + connection_key()); + if (!app.valid()) { + LOG4CXX_ERROR(logger_, "No application associated with session key"); + return; + } + app->RemoveCommand((*message_)[strings::msg_params] + [strings::cmd_id].asUInt()); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/add_command_response.cc b/src/components/application_manager/src/commands/mobile/add_command_response.cc new file mode 100644 index 0000000000..0c135af076 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/add_command_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/add_command_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +AddCommandResponse::AddCommandResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +AddCommandResponse::~AddCommandResponse() { +} + +void AddCommandResponse::Run() { + LOG4CXX_INFO(logger_, "AddCommandResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/add_sub_menu_request.cc b/src/components/application_manager/src/commands/mobile/add_sub_menu_request.cc new file mode 100644 index 0000000000..ce6fa3fc51 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/add_sub_menu_request.cc @@ -0,0 +1,146 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/add_sub_menu_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application.h" + +namespace application_manager { + +namespace commands { + +AddSubMenuRequest::AddSubMenuRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +AddSubMenuRequest::~AddSubMenuRequest() { +} + +void AddSubMenuRequest::Run() { + LOG4CXX_INFO(logger_, "AddSubMenuRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (app->FindSubMenu( + (*message_)[strings::msg_params][strings::menu_id].asInt())) { + LOG4CXX_ERROR(logger_, "INVALID_ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return; + } + + if (app->IsSubMenuNameAlreadyExist( + (*message_)[strings::msg_params][strings::menu_name].asString())) { + LOG4CXX_ERROR(logger_, "DUPLICATE_NAME"); + SendResponse(false, mobile_apis::Result::DUPLICATE_NAME); + return; + } + + if (!CheckSubMenuName()) { + LOG4CXX_ERROR(logger_, "SubMenuName is not valid"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::menu_id] = + (*message_)[strings::msg_params][strings::menu_id]; + if ((*message_)[strings::msg_params].keyExists(strings::position)) { + msg_params[strings::menu_params][strings::position] = + (*message_)[strings::msg_params][strings::position]; + } + msg_params[strings::menu_params][strings::menu_name] = + (*message_)[strings::msg_params][strings::menu_name]; + msg_params[strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::UI_AddSubMenu, &msg_params, true); +} + +void AddSubMenuRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "AddSubMenuRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_AddSubMenu: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + if (result) { + application->AddSubMenu((*message_)[strings::msg_params] + [strings::menu_id].asInt(), + (*message_)[strings::msg_params]); + } + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + application->UpdateHash(); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +bool AddSubMenuRequest::CheckSubMenuName() { + const char* str = NULL; + + str = (*message_)[strings::msg_params][strings::menu_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_INFO(logger_, "Invalid subMenu name."); + return false; + } + return true; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/add_sub_menu_response.cc b/src/components/application_manager/src/commands/mobile/add_sub_menu_response.cc new file mode 100644 index 0000000000..bcd7df2888 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/add_sub_menu_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/add_sub_menu_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +AddSubMenuResponse::AddSubMenuResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +AddSubMenuResponse::~AddSubMenuResponse() { +} + +void AddSubMenuResponse::Run() { + LOG4CXX_INFO(logger_, "AddSubMenuResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc b/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc new file mode 100644 index 0000000000..abb5bc7f3c --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/alert_maneuver_request.cc @@ -0,0 +1,232 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include "application_manager/commands/mobile/alert_maneuver_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +AlertManeuverRequest::AlertManeuverRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message), + tts_speak_result_code_(mobile_apis::Result::INVALID_ENUM), + navi_alert_maneuver_result_code_(mobile_apis::Result::INVALID_ENUM) { + subscribe_on_event(hmi_apis::FunctionID::TTS_OnResetTimeout); +} + +AlertManeuverRequest::~AlertManeuverRequest() { +} + +void AlertManeuverRequest::Run() { + LOG4CXX_INFO(logger_, "AlertManeuverRequest::Run"); + + if ((!(*message_)[strings::msg_params].keyExists(strings::soft_buttons)) && + (!(*message_)[strings::msg_params].keyExists(strings::tts_chunks))) { + LOG4CXX_ERROR(logger_, "AlertManeuverRequest::Request without parameters!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (NULL == app.get()) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming alert maneuver has contains \\t\\n \\\\t \\\\n" + "text contains only whitespace in ttsChunks"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + //ProcessSoftButtons checks strings on the contents incorrect character + + mobile_apis::Result::eType processing_result = + MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app); + + if (mobile_apis::Result::SUCCESS != processing_result) { + LOG4CXX_ERROR(logger_, "Wrong soft buttons parameters!"); + SendResponse(false, processing_result); + return; + } + + // Checking parameters and how many HMI requests should be sent + bool tts_is_ok = false; + + // check TTSChunk parameter + if ((*message_)[strings::msg_params].keyExists(strings::tts_chunks)) { + if (0 < (*message_)[strings::msg_params][strings::tts_chunks].length()) { + pending_requests_.Add(hmi_apis::FunctionID::TTS_Speak); + tts_is_ok = true; + } + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + 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()); + } + + pending_requests_.Add(hmi_apis::FunctionID::Navigation_AlertManeuver); + SendHMIRequest(hmi_apis::FunctionID::Navigation_AlertManeuver, + &msg_params, true); + + if (tts_is_ok) { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[hmi_request::tts_chunks] = + (*message_)[strings::msg_params][strings::tts_chunks]; + + msg_params[strings::app_id] = app->app_id(); + SendHMIRequest(hmi_apis::FunctionID::TTS_Speak, &msg_params, true); + } +} + +void AlertManeuverRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "AlertManeuverRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM; + hmi_apis::FunctionID::eType event_id = event.id(); + switch (event_id) { + case hmi_apis::FunctionID::Navigation_AlertManeuver: { + LOG4CXX_INFO(logger_, "Received Navigation_AlertManeuver event"); + + pending_requests_.Remove(event_id); + + navi_alert_maneuver_result_code_ = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + break; + } + case hmi_apis::FunctionID::TTS_Speak: { + LOG4CXX_INFO(logger_, "Received TTS_Speak event"); + + pending_requests_.Remove(event_id); + + tts_speak_result_code_ = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + break; + } + case hmi_apis::FunctionID::TTS_OnResetTimeout: { + LOG4CXX_INFO(logger_, "Received TTS_OnResetTimeout event"); + + ApplicationManagerImpl::instance()->updateRequestTimeout( + connection_key(), correlation_id(), default_timeout()); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + SendResponse(false, result_code, "Received unknown event"); + return; + } + } + + if (pending_requests_.IsFinal(event_id)) { + + bool result = ((hmi_apis::Common_Result::SUCCESS == + static_cast<hmi_apis::Common_Result::eType>(tts_speak_result_code_) || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == + static_cast<hmi_apis::Common_Result::eType>(tts_speak_result_code_) || + (hmi_apis::Common_Result::INVALID_ENUM == + static_cast<hmi_apis::Common_Result::eType>(tts_speak_result_code_))) && + (hmi_apis::Common_Result::SUCCESS == + static_cast<hmi_apis::Common_Result::eType>(navi_alert_maneuver_result_code_))) || + (hmi_apis::Common_Result::SUCCESS == static_cast<hmi_apis::Common_Result::eType>( + tts_speak_result_code_) && hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == + static_cast<hmi_apis::Common_Result::eType>(navi_alert_maneuver_result_code_)); + + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>(std::max(tts_speak_result_code_, + navi_alert_maneuver_result_code_)); + + const char* return_info = NULL; + + if (result && hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == + static_cast<hmi_apis::Common_Result::eType>(tts_speak_result_code_)) { + result_code = mobile_apis::Result::WARNINGS; + return_info = + std::string("Unsupported phoneme type sent in a prompt").c_str(); + } + + SendResponse(result, result_code, return_info, + &(message[strings::msg_params])); + } else { + LOG4CXX_INFO(logger_, + "There are some pending responses from HMI." + "AlertManeuverRequest still waiting."); + } +} + +bool AlertManeuverRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "AlertManeuverRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::tts_chunks)) { + const smart_objects::SmartArray* tc_array = + (*message_)[strings::msg_params][strings::tts_chunks].asArray(); + + smart_objects::SmartArray::const_iterator it_tc = tc_array->begin(); + smart_objects::SmartArray::const_iterator it_tc_end = tc_array->end(); + + for (; it_tc != it_tc_end; ++it_tc) { + str = (*it_tc)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid tts_chunks syntax check failed"); + return true; + } + } + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/alert_maneuver_response.cc b/src/components/application_manager/src/commands/mobile/alert_maneuver_response.cc new file mode 100644 index 0000000000..99fcde69a8 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/alert_maneuver_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/alert_maneuver_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +AlertManeuverResponse::AlertManeuverResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +AlertManeuverResponse::~AlertManeuverResponse() { +} + +void AlertManeuverResponse::Run() { + LOG4CXX_INFO(logger_, "AlertManeuverResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/alert_request.cc b/src/components/application_manager/src/commands/mobile/alert_request.cc new file mode 100644 index 0000000000..c08b7c32d7 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/alert_request.cc @@ -0,0 +1,415 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/alert_request.h" + +#include <string.h> + +#include "application_manager/message_helper.h" +#include "application_manager/application_impl.h" +#include "application_manager/application_manager_impl.h" + + +namespace application_manager { + +namespace commands { + +namespace smart_objects = NsSmartDeviceLink::NsSmartObjects; + +AlertRequest::AlertRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message), + awaiting_ui_alert_response_(false), + awaiting_tts_speak_response_(false), + awaiting_tts_stop_speaking_response_(false), + response_success_(false), + flag_other_component_sent_(false), + response_result_(mobile_apis::Result::INVALID_ENUM), + tts_speak_response_(mobile_apis::Result::INVALID_ENUM) { + subscribe_on_event(hmi_apis::FunctionID::UI_OnResetTimeout); + subscribe_on_event(hmi_apis::FunctionID::TTS_OnResetTimeout); +} + +AlertRequest::~AlertRequest() { +} + +bool AlertRequest::Init() { + /* Timeout in milliseconds. + If omitted a standard value of 10000 milliseconds is used.*/ + if ((*message_)[strings::msg_params].keyExists(strings::duration)) { + default_timeout_ = + (*message_)[strings::msg_params][strings::duration].asUInt(); + } else { + const int32_t def_value = 5000; + default_timeout_ = def_value; + } + + // If soft buttons are present, SDL will not use initiate timeout tracking for response. + if ((*message_)[strings::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 AlertRequest::Run() { + LOG4CXX_INFO(logger_, "AlertRequest::Run"); + + uint32_t app_id = (*message_)[strings::params][strings::connection_key] + .asInt(); + + if (!Validate(app_id)) { + // Invalid command, abort execution + return; + } + + if ((*message_)[strings::msg_params].keyExists(strings::tts_chunks)) { + if (0 < (*message_)[strings::msg_params][strings::tts_chunks].length()) { + awaiting_tts_speak_response_ = true; + } + } + SendAlertRequest(app_id); + SendPlayToneNotification(app_id); + if (awaiting_tts_speak_response_) { + SendSpeakRequest(app_id); + } +} + +void AlertRequest::onTimeOut() { + if (false == (*message_)[strings::msg_params].keyExists(strings::soft_buttons)) { + CommandRequestImpl::onTimeOut(); + return; + } + LOG4CXX_INFO(logger_, "default timeout ignored. " + "AlertRequest with soft buttons wait timeout on HMI side"); +} + +void AlertRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "AlertRequest::on_event"); + 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_alert_response_); + ApplicationManagerImpl::instance()->updateRequestTimeout( + connection_key(), correlation_id(), default_timeout()); + break; + } + case hmi_apis::FunctionID::UI_Alert: { + LOG4CXX_INFO(logger_, "Received UI_Alert event"); + // Unsubscribe from event to avoid unwanted messages + unsubscribe_from_event(hmi_apis::FunctionID::UI_Alert); + awaiting_ui_alert_response_ = false; + + if (awaiting_tts_speak_response_) { + awaiting_tts_stop_speaking_response_ = true; + SendHMIRequest(hmi_apis::FunctionID::TTS_StopSpeaking, NULL, true); + } + + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + // Mobile Alert request is successful when UI_Alert is successful + response_success_ = (mobile_apis::Result::SUCCESS == result_code || + mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code); + response_result_ = result_code; + response_params_ = message[strings::msg_params]; + break; + } + case hmi_apis::FunctionID::TTS_Speak: { + LOG4CXX_INFO(logger_, "Received TTS_Speak event"); + // Unsubscribe from event to avoid unwanted messages + unsubscribe_from_event(hmi_apis::FunctionID::TTS_Speak); + awaiting_tts_speak_response_ = false; + tts_speak_response_ = static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + case hmi_apis::FunctionID::TTS_StopSpeaking: { + LOG4CXX_INFO(logger_, "Received TTS_StopSpeaking event"); + // 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()) { + std::string response_info(""); + if ((mobile_apis::Result::UNSUPPORTED_RESOURCE == tts_speak_response_) && + (!flag_other_component_sent_)) { + response_success_ = false; + response_result_ = mobile_apis::Result::WARNINGS; + response_info = "Unsupported phoneme type sent in a prompt"; + } else if ((mobile_apis::Result::UNSUPPORTED_RESOURCE == + tts_speak_response_) && (mobile_apis::Result::UNSUPPORTED_RESOURCE == + response_result_)) { + response_result_ = mobile_apis::Result::WARNINGS; + response_info = "Unsupported phoneme type sent in a prompt and " + "unsupported image sent in soft buttons"; + } else if ((mobile_apis::Result::UNSUPPORTED_RESOURCE == + tts_speak_response_) && (mobile_apis::Result::SUCCESS == + response_result_)) { + response_result_ = mobile_apis::Result::WARNINGS; + response_info = "Unsupported phoneme type sent in a prompt"; + } else if ((mobile_apis::Result::SUCCESS == tts_speak_response_) && + ((mobile_apis::Result::INVALID_ENUM == response_result_) && + (!flag_other_component_sent_))) { + response_result_ = mobile_apis::Result::SUCCESS; + response_success_ = true; + } + + // If timeout is not set, watchdog will not track request timeout and + // HMI is responsible for response returning. In this case, if ABORTED will + // be rerurned from HMI, success should be sent to mobile. + if (mobile_apis::Result::ABORTED == response_result_ && + 0 == default_timeout_) { + response_success_ = true; + } + + if (mobile_apis::Result::ABORTED == tts_speak_response_ && + (!flag_other_component_sent_)) { + response_success_ = false; + response_result_ = tts_speak_response_; + } + + SendResponse(response_success_, response_result_, + response_info.empty() ? NULL : response_info.c_str(), + &response_params_); + } +} + +bool AlertRequest::Validate(uint32_t app_id) { + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + + if (!app) { + LOG4CXX_ERROR_EXT(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() && + app->IsCommandLimitsExceeded( + static_cast<mobile_apis::FunctionID::eType>(function_id()), + application_manager::TLimitSource::POLICY_TABLE)) { + LOG4CXX_ERROR(logger_, "Alert frequency is too high."); + SendResponse(false, mobile_apis::Result::REJECTED); + return false; + } + + if (!CheckStringsOfAlertRequest()) { + 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); + + 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) + && (1 > (*message_)[strings::msg_params] + [strings::tts_chunks].length()))) { + LOG4CXX_ERROR_EXT(logger_, "Mandatory parameters are missing"); + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "Mandatory parameters are missing"); + return false; + } + + return true; +} + +void AlertRequest::SendAlertRequest(int32_t app_id) { + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->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); + + 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::alertText1; + 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::alertText2; + msg_params[hmi_request::alert_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::alert_text2]; + index++; + } + if ((*message_)[strings::msg_params].keyExists(strings::alert_text3)) { + msg_params[hmi_request::alert_strings][index][hmi_request::field_name] = + hmi_apis::Common_TextFieldName::alertText3; + msg_params[hmi_request::alert_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::alert_text3]; + } + + // 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()); + } + // app_id + msg_params[strings::app_id] = app_id; + msg_params[strings::duration] = default_timeout_; + + // NAVI platform progressIndicator + if ((*message_)[strings::msg_params].keyExists(strings::progress_indicator)) { + msg_params[strings::progress_indicator] = + (*message_)[strings::msg_params][strings::progress_indicator]; + } + + // 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_alert_response_ = true; + flag_other_component_sent_ = true; + SendHMIRequest(hmi_apis::FunctionID::UI_Alert, &msg_params, true); + } +} + +void AlertRequest::SendSpeakRequest(int32_t app_id) { + + // crate HMI speak request + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[hmi_request::tts_chunks] = smart_objects::SmartObject( + smart_objects::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] = + hmi_apis::Common_SpeakType::ALERT; + SendHMIRequest(hmi_apis::FunctionID::TTS_Speak, &msg_params, true); +} + +void AlertRequest::SendPlayToneNotification(int32_t app_id) { + LOG4CXX_INFO(logger_, "AlertRequest::SendPlayToneNotification"); + + // check playtone parameter + if ((*message_)[strings::msg_params].keyExists(strings::play_tone)) { + if ((*message_)[strings::msg_params][strings::play_tone].asBool()) { + // crate HMI basic communication playtone request + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + CreateHMINotification(hmi_apis::FunctionID::BasicCommunication_PlayTone, + msg_params); + } + } +} + +bool AlertRequest::CheckStringsOfAlertRequest() { + LOG4CXX_INFO(logger_, "AlertRequest::CheckStringsOfAlertRequest"); + 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::alert_text3)) { + str = (*message_)[strings::msg_params][strings::alert_text3].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid alert_text_3 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 AlertRequest::HasHmiResponsesToWait() { + return awaiting_ui_alert_response_ || awaiting_tts_speak_response_ + || awaiting_tts_stop_speaking_response_; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/alert_response.cc b/src/components/application_manager/src/commands/mobile/alert_response.cc new file mode 100644 index 0000000000..5b8cd6557b --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/alert_response.cc @@ -0,0 +1,59 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/alert_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +AlertResponse::AlertResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +AlertResponse::~AlertResponse() { +} + +void AlertResponse::Run() { + LOG4CXX_INFO(logger_, "AlertResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/change_registration_request.cc b/src/components/application_manager/src/commands/mobile/change_registration_request.cc new file mode 100644 index 0000000000..9780aad7bb --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/change_registration_request.cc @@ -0,0 +1,433 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include <algorithm> +#include "application_manager/commands/mobile/change_registration_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ChangeRegistrationRequest::ChangeRegistrationRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message), + ui_result_(hmi_apis::Common_Result::INVALID_ENUM), + vr_result_(hmi_apis::Common_Result::INVALID_ENUM), + tts_result_(hmi_apis::Common_Result::INVALID_ENUM) { +} + +ChangeRegistrationRequest::~ChangeRegistrationRequest() { +} + +void ChangeRegistrationRequest::Run() { + LOG4CXX_INFO(logger_, "ChangeRegistrationRequest::Run"); + + ApplicationManagerImpl* instance = ApplicationManagerImpl::instance(); + const HMICapabilities& hmi_capabilities = instance->hmi_capabilities(); + + ApplicationSharedPtr app = instance->application(connection_key()); + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_INFO(logger_, + "Incoming request contains \t\n \\t \\n or whitespace"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if (mobile_apis::Result::SUCCESS != CheckCoincidence()) { + SendResponse(false, mobile_apis::Result::DUPLICATE_NAME); + return; + } + + if (!hmi_capabilities.is_ui_cooperating()) { + ui_result_ = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + } + + if (!hmi_capabilities.is_vr_cooperating()) { + vr_result_ = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + } + + if (!hmi_capabilities.is_tts_cooperating()) { + tts_result_ = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE; + } + + const int32_t hmi_language = + (*message_)[strings::msg_params][strings::hmi_display_language].asInt(); + + const int32_t language = + (*message_)[strings::msg_params][strings::language].asInt(); + + if (false == + (IsLanguageSupportedByUI(hmi_language) && + IsLanguageSupportedByVR(language) && + IsLanguageSupportedByTTS(language))) { + LOG4CXX_ERROR(logger_, "Language is not supported"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + pending_requests_.Add(hmi_apis::FunctionID::UI_ChangeRegistration); + pending_requests_.Add(hmi_apis::FunctionID::VR_ChangeRegistration); + pending_requests_.Add(hmi_apis::FunctionID::TTS_ChangeRegistration); + + // UI processing + smart_objects::SmartObject ui_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + ui_params[strings::language] = hmi_language; + ui_params[strings::app_id] = app->app_id(); + if ((*message_)[strings::msg_params].keyExists(strings::app_name)) { + ui_params[strings::app_name] = + (*message_)[strings::msg_params][strings::app_name]; + app->set_name((*message_)[strings::msg_params][strings::app_name].asString()); + } + if ((*message_)[strings::msg_params].keyExists( + strings::ngn_media_screen_app_name)) { + ui_params[strings::ngn_media_screen_app_name] = + (*message_)[strings::msg_params][strings::ngn_media_screen_app_name]; + app->set_ngn_media_screen_name((*message_)[strings::msg_params] + [strings::ngn_media_screen_app_name]); + } + + SendHMIRequest(hmi_apis::FunctionID::UI_ChangeRegistration, + &ui_params, true); + + // VR processing + smart_objects::SmartObject vr_params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + + vr_params[strings::language] = + (*message_)[strings::msg_params][strings::language]; + + vr_params[strings::app_id] = app->app_id(); + if ((*message_)[strings::msg_params].keyExists(strings::vr_synonyms)) { + vr_params[strings::vr_synonyms] = (*message_)[strings::msg_params] + [strings::vr_synonyms]; + app -> set_vr_synonyms((*message_)[strings::msg_params][strings::vr_synonyms]); + } + SendHMIRequest(hmi_apis::FunctionID::VR_ChangeRegistration, + &vr_params, true); + + // TTS processing + smart_objects::SmartObject tts_params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + + tts_params[strings::language] = + (*message_)[strings::msg_params][strings::language]; + + tts_params[strings::app_id] = app->app_id(); + if ((*message_)[strings::msg_params].keyExists(strings::tts_name)) { + tts_params[strings::tts_name] = (*message_)[strings::msg_params] + [strings::tts_name]; + app->set_tts_name((*message_)[strings::msg_params][strings::tts_name]); + } + + SendHMIRequest(hmi_apis::FunctionID::TTS_ChangeRegistration, + &tts_params, true); +} + +bool ChangeRegistrationRequest::WasAnySuccess( + const hmi_apis::Common_Result::eType ui, + const hmi_apis::Common_Result::eType vr, + const hmi_apis::Common_Result::eType tts) { + + return + hmi_apis::Common_Result::SUCCESS == ui || + hmi_apis::Common_Result::SUCCESS == vr || + hmi_apis::Common_Result::SUCCESS == tts; +} + +void ChangeRegistrationRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ChangeRegistrationRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + hmi_apis::FunctionID::eType event_id = event.id(); + + switch (event_id) { + case hmi_apis::FunctionID::UI_ChangeRegistration: { + LOG4CXX_INFO(logger_, "Received UI_ChangeRegistration event"); + pending_requests_.Remove(event_id); + ui_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + case hmi_apis::FunctionID::VR_ChangeRegistration: { + LOG4CXX_INFO(logger_, "Received VR_ChangeRegistration event"); + pending_requests_.Remove(event_id); + vr_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + case hmi_apis::FunctionID::TTS_ChangeRegistration: { + LOG4CXX_INFO(logger_, "Received TTS_ChangeRegistration event"); + pending_requests_.Remove(event_id); + tts_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event_id); + return; + } + } + + if (pending_requests_.IsFinal(event_id)) { + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + if (hmi_apis::Common_Result::SUCCESS == ui_result_) { + application->set_ui_language(static_cast<mobile_api::Language::eType>( + (*message_)[strings::msg_params][strings::hmi_display_language].asInt())); + } + + if (hmi_apis::Common_Result::SUCCESS == vr_result_ + || hmi_apis::Common_Result::SUCCESS == tts_result_) { + application->set_language(static_cast<mobile_api::Language::eType>( + (*message_)[strings::msg_params][strings::language].asInt())); + } + + int32_t greates_result_code = std::max(std::max(ui_result_, vr_result_), + tts_result_); + + (*message_)[strings::params][strings::function_id] = + mobile_apis::FunctionID::eType::ChangeRegistrationID; + + SendResponse(WasAnySuccess(ui_result_, vr_result_, tts_result_), + static_cast<mobile_apis::Result::eType>(greates_result_code), + NULL, &(message[strings::msg_params])); + } else { + LOG4CXX_INFO(logger_, + "There are some pending responses from HMI." + "ChangeRegistrationRequest still waiting."); + } +} + +bool ChangeRegistrationRequest::IsLanguageSupportedByUI( + const int32_t& hmi_display_lang) { + + const HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + const smart_objects::SmartObject* ui_languages = + hmi_capabilities.ui_supported_languages(); + + if (!ui_languages) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return false; + } + + for (size_t i = 0; i < ui_languages->length(); ++i) { + if (hmi_display_lang == ui_languages->getElement(i).asInt()) { + return true; + } + } + + LOG4CXX_ERROR(logger_, "Language isn't supported by UI"); + + return false; +} + +bool ChangeRegistrationRequest::IsLanguageSupportedByVR( + const int32_t& hmi_display_lang) { + const HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + const smart_objects::SmartObject* vr_languages = + hmi_capabilities.vr_supported_languages(); + + if (!vr_languages) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return false; + } + + for (size_t i = 0; i < vr_languages->length(); ++i) { + if (hmi_display_lang == vr_languages->getElement(i).asInt()) { + return true; + } + } + + LOG4CXX_ERROR(logger_, "Language isn't supported by VR"); + + return false; +} + +bool ChangeRegistrationRequest::IsLanguageSupportedByTTS( + const int32_t& hmi_display_lang) { + const HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + const smart_objects::SmartObject* tts_languages = + hmi_capabilities.tts_supported_languages(); + + if (!tts_languages) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return false; + } + + for (size_t i = 0; i < tts_languages->length(); ++i) { + if (hmi_display_lang == tts_languages->getElement(i).asInt()) { + return true; + break; + } + } + + LOG4CXX_ERROR(logger_, "Language isn't supported by TTS"); + return false; +} + +bool ChangeRegistrationRequest::IsWhiteSpaceExist() { + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::app_name)) { + str = (*message_)[strings::msg_params][strings::app_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid app_name syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::tts_name)) { + const smart_objects::SmartArray* tn_array = + (*message_)[strings::msg_params][strings::tts_name].asArray(); + + smart_objects::SmartArray::const_iterator it_tn = tn_array->begin(); + smart_objects::SmartArray::const_iterator it_tn_end = tn_array->end(); + + for (; it_tn != it_tn_end; ++it_tn) { + str = (*it_tn)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid tts_name syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params]. + keyExists(strings::ngn_media_screen_app_name)) { + str = (*message_)[strings::msg_params] + [strings::ngn_media_screen_app_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid ngn_media_screen_app_name syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::vr_synonyms)) { + const smart_objects::SmartArray* vs_array = + (*message_)[strings::msg_params][strings::vr_synonyms].asArray(); + + smart_objects::SmartArray::const_iterator it_vs = vs_array->begin(); + smart_objects::SmartArray::const_iterator it_vs_end = vs_array->end(); + + for (; it_vs != it_vs_end; ++it_vs) { + str = (*it_vs).asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_synonyms syntax check failed"); + return true; + } + } + } + return false; +} + +mobile_apis::Result::eType ChangeRegistrationRequest::CheckCoincidence() { + LOG4CXX_INFO(logger_, "ChangeRegistrationRequest::CheckCoincidence"); + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + std::set<ApplicationSharedPtr>::const_iterator it = applications.begin(); + std::string app_name; + uint32_t app_id = connection_key(); + if (msg_params.keyExists(strings::app_name)) { + app_name = msg_params[strings::app_name].asString(); + } + + for (; applications.end() != it; ++it) { + if (app_id == (*it)->app_id()) { + continue; + } + + const std::string& cur_name = (*it)->name(); + if (msg_params.keyExists(strings::app_name)) { + if (!strcasecmp(app_name.c_str(), cur_name.c_str())) { + LOG4CXX_ERROR(logger_, "Application name is known already."); + return mobile_apis::Result::DUPLICATE_NAME; + } + + const smart_objects::SmartObject* vr = (*it)->vr_synonyms(); + const std::vector<smart_objects::SmartObject>* curr_vr = NULL; + if (NULL != vr) { + curr_vr = vr->asArray(); + CoincidencePredicateVR v(app_name); + + if (0 != std::count_if(curr_vr->begin(), curr_vr->end(), v)) { + LOG4CXX_ERROR(logger_, "Application name is known already."); + return mobile_apis::Result::DUPLICATE_NAME; + } + } + } + + // vr check + if (msg_params.keyExists(strings::vr_synonyms)) { + const std::vector<smart_objects::SmartObject>* new_vr = + msg_params[strings::vr_synonyms].asArray(); + + CoincidencePredicateVR v(cur_name); + if (0 != std::count_if(new_vr->begin(), new_vr->end(), v)) { + LOG4CXX_ERROR(logger_, "vr_synonyms duplicated with app_name ."); + return mobile_apis::Result::DUPLICATE_NAME; + } + } // end vr check + } // application for end + return mobile_apis::Result::SUCCESS; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/change_registration_response.cc b/src/components/application_manager/src/commands/mobile/change_registration_response.cc new file mode 100644 index 0000000000..13c926ec82 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/change_registration_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/change_registration_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +ChangeRegistrationResponse::ChangeRegistrationResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +ChangeRegistrationResponse::~ChangeRegistrationResponse() { +} + +void ChangeRegistrationResponse::Run() { + LOG4CXX_INFO(logger_, "ChangeRegistrationResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/create_interaction_choice_set_request.cc b/src/components/application_manager/src/commands/mobile/create_interaction_choice_set_request.cc new file mode 100644 index 0000000000..583f0a0460 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/create_interaction_choice_set_request.cc @@ -0,0 +1,343 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include <string> +#include <algorithm> +#include <vector> +#include "application_manager/commands/mobile/create_interaction_choice_set_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +CreateInteractionChoiceSetRequest::CreateInteractionChoiceSetRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +CreateInteractionChoiceSetRequest::~CreateInteractionChoiceSetRequest() { +} + +void CreateInteractionChoiceSetRequest::Run() { + LOG4CXX_INFO(logger_, "CreateInteractionChoiceSetRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + for (uint32_t i = 0; + i < (*message_)[strings::msg_params][strings::choice_set].length(); + ++i) { + mobile_apis::Result::eType verification_result_image = + mobile_apis::Result::SUCCESS; + mobile_apis::Result::eType verification_result_secondary_image = + mobile_apis::Result::SUCCESS; + if ((*message_)[strings::msg_params] + [strings::choice_set][i].keyExists(strings::image)) { + verification_result_image = MessageHelper::VerifyImage( + (*message_)[strings::msg_params][strings::choice_set] + [i][strings::image], app); + } + if ((*message_)[strings::msg_params] + [strings::choice_set][i].keyExists(strings::secondary_image)) { + verification_result_secondary_image = MessageHelper::VerifyImage( + (*message_)[strings::msg_params][strings::choice_set] + [i][strings::secondary_image], app); + } + if (verification_result_image == mobile_apis::Result::INVALID_DATA || + verification_result_secondary_image == mobile_apis::Result::INVALID_DATA) { + LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + } + + const int32_t choice_set_id = (*message_)[strings::msg_params] + [strings::interaction_choice_set_id].asInt(); + + if (app->FindChoiceSet(choice_set_id)) { + LOG4CXX_ERROR(logger_, "Invalid ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return; + } + + mobile_apis::Result::eType result = CheckChoiceSet(app); + if (mobile_apis::Result::SUCCESS != result) { + SendResponse(false, result); + return; + } + uint32_t grammar_id = ApplicationManagerImpl::instance()->GenerateGrammarID(); + (*message_)[strings::msg_params][strings::grammar_id] = grammar_id; + app->AddChoiceSet(choice_set_id, (*message_)[strings::msg_params]); + SendVRAddCommandRequest(app); + SendResponse(true, mobile_apis::Result::SUCCESS); + app->UpdateHash(); +} + +mobile_apis::Result::eType CreateInteractionChoiceSetRequest::CheckChoiceSet( + ApplicationConstSharedPtr app) { + LOG4CXX_INFO(logger_, "CreateInteractionChoiceSetRequest::CheckChoiceSet"); + + const smart_objects::SmartArray* new_choice_set_array = + (*message_)[strings::msg_params][strings::choice_set].asArray(); + + smart_objects::SmartArray::const_iterator it_array = + new_choice_set_array->begin(); + + smart_objects::SmartArray::const_iterator it_array_end = + new_choice_set_array->end(); + + // Self check of new choice set for params coincidence + for (; it_array != it_array_end; ++it_array) { + const smart_objects::SmartArray* vr_array = + (*it_array)[strings::vr_commands].asArray(); + + CoincidencePredicateChoiceID c((*it_array)[strings::choice_id].asInt()); + if (1 != std::count_if( + new_choice_set_array->begin(), + new_choice_set_array->end(), + c)) { + + LOG4CXX_ERROR(logger_, "Incoming choice set has duplicate IDs."); + return mobile_apis::Result::INVALID_ID; + } + + // Check new choice set params along with already registered choice sets + const ChoiceSetMap& app_choice_set_map = app->choice_set_map(); + ChoiceSetMap::const_iterator it = app_choice_set_map.begin(); + ChoiceSetMap::const_iterator itEnd = app_choice_set_map.end(); + for (; it != itEnd; ++it) { + const smart_objects::SmartObject* app_choice_set = it->second; + if (NULL != app_choice_set) { + + const smart_objects::SmartArray* curr_choice_set = + (*app_choice_set)[strings::choice_set].asArray(); + + if (0 != std::count_if( + curr_choice_set->begin(), + curr_choice_set->end(), + c)) { + LOG4CXX_ERROR(logger_, "Incoming choice ID already exists."); + return mobile_apis::Result::INVALID_ID; + } + } + } + + CoincidencePredicateMenuName m((*it_array)[strings::menu_name].asString()); + if (1 != std::count_if( + new_choice_set_array->begin(), + new_choice_set_array->end(), + m)) { + + LOG4CXX_ERROR(logger_, "Incoming choice set has duplicate menu names."); + return mobile_apis::Result::DUPLICATE_NAME; + } + + // Check coincidence inside the current choice + + smart_objects::SmartArray::const_iterator it_vr = vr_array->begin(); + smart_objects::SmartArray::const_iterator it_vr_end = vr_array->end(); + + for (; it_vr != it_vr_end; ++it_vr) { + CoincidencePredicateVRCommands v((*it_vr)); + if (1 != std::count_if(vr_array->begin(), vr_array->end(), v)) { + + LOG4CXX_ERROR(logger_, + "Incoming choice set has duplicate VR command(s)"); + + return mobile_apis::Result::DUPLICATE_NAME; + } + } + + // Check along with VR commands in other choices in the new set + smart_objects::SmartArray::const_iterator it_same_array = + new_choice_set_array->begin(); + + smart_objects::SmartArray::const_iterator it_same_array_end = + new_choice_set_array->end(); + + for (; it_same_array != it_same_array_end; ++it_same_array) { + + // Skip check for itself + if ((*it_array)[strings::choice_id] == + (*it_same_array)[strings::choice_id]) { + + continue; + } + + if (compareSynonyms((*it_array), (*it_same_array))) { + + LOG4CXX_ERROR(logger_, + "Incoming choice set has duplicate VR command(s)."); + + return mobile_apis::Result::DUPLICATE_NAME; + } + } + + if (IsWhiteSpaceExist((*it_array))) { + LOG4CXX_ERROR(logger_, + "Incoming choice set has contains \t\n \\t \\n"); + return mobile_apis::Result::INVALID_DATA; + } + } + + return mobile_apis::Result::SUCCESS; +} + +bool CreateInteractionChoiceSetRequest::compareSynonyms( + const NsSmartDeviceLink::NsSmartObjects::SmartObject& choice1, + const NsSmartDeviceLink::NsSmartObjects::SmartObject& choice2) { + + smart_objects::SmartArray* vr_cmds_1 = + choice1[strings::vr_commands].asArray(); + DCHECK(vr_cmds_1 != NULL); + smart_objects::SmartArray* vr_cmds_2 = + choice2[strings::vr_commands].asArray(); + DCHECK(vr_cmds_2 != NULL); + + smart_objects::SmartArray::iterator it; + it = std::find_first_of(vr_cmds_1->begin(), vr_cmds_1->end(), + vr_cmds_2->begin(), vr_cmds_2->end(), + CreateInteractionChoiceSetRequest::compareStr); + + + if (it != vr_cmds_1->end()) { + LOG4CXX_INFO(logger_, "Incoming choice set has duplicated VR synonyms " + << it->asString()); + return true; + } + + return false; +} + +bool CreateInteractionChoiceSetRequest::compareStr( + const NsSmartDeviceLink::NsSmartObjects::SmartObject& str1, + const NsSmartDeviceLink::NsSmartObjects::SmartObject& str2) { + + return 0 == strcasecmp(str1.asCharArray(), str2.asCharArray()); +} + +bool CreateInteractionChoiceSetRequest::IsWhiteSpaceExist( + const smart_objects::SmartObject& choice_set) { + LOG4CXX_INFO(logger_, "CreateInteractionChoiceSetRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + str = choice_set[strings::menu_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid menu_name syntax check failed"); + return true; + } + + if (choice_set.keyExists(strings::secondary_text)) { + str = choice_set[strings::secondary_text].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid secondary_text syntax check failed"); + return true; + } + } + + if (choice_set.keyExists(strings::tertiary_text)) { + str = choice_set[strings::tertiary_text].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid tertiary_text syntax check failed"); + return true; + } + } + + if (choice_set.keyExists(strings::vr_commands)) { + const size_t len = + choice_set[strings::vr_commands].length(); + + for (size_t i = 0; i < len; ++i) { + str = choice_set[strings::vr_commands][i].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_commands syntax check failed"); + return true; + } + } + } + + if (choice_set.keyExists(strings::image)) { + str = choice_set[strings::image][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid image value syntax check failed"); + return true; + } + } + + if (choice_set.keyExists(strings::secondary_image)) { + str = choice_set[strings::secondary_image][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid secondary_image value syntax check failed"); + return true; + } + } + return false; +} + +void CreateInteractionChoiceSetRequest::SendVRAddCommandRequest( + application_manager::ApplicationSharedPtr const app) { + + smart_objects::SmartObject* choice_set = &(*message_)[strings::msg_params]; + + for (size_t j = 0; j < (*choice_set)[strings::choice_set].length(); ++j) { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::cmd_id] = + (*choice_set)[strings::choice_set][j][strings::choice_id]; + msg_params[strings::vr_commands] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + msg_params[strings::vr_commands] = + (*choice_set)[strings::choice_set][j][strings::vr_commands]; + + msg_params[strings::type] = hmi_apis::Common_VRCommandType::Choice; + msg_params[strings::grammar_id] = (*choice_set)[strings::grammar_id]; + + SendHMIRequest(hmi_apis::FunctionID::VR_AddCommand, &msg_params); + } + +} + + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/create_interaction_choice_set_response.cc b/src/components/application_manager/src/commands/mobile/create_interaction_choice_set_response.cc new file mode 100644 index 0000000000..8d6ea1b348 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/create_interaction_choice_set_response.cc @@ -0,0 +1,68 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/create_interaction_choice_set_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +CreateInteractionChoiceSetResponse::CreateInteractionChoiceSetResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +CreateInteractionChoiceSetResponse::~CreateInteractionChoiceSetResponse() { +} + +void CreateInteractionChoiceSetResponse::Run() { + LOG4CXX_INFO(logger_, "CreateInteractionChoiceSetResponse::Run"); + + // check if response false + if (true == (*message_)[strings::msg_params].keyExists(strings::success)) { + if ((*message_)[strings::msg_params][strings::success].asBool() == false) { + LOG4CXX_ERROR(logger_, "Success = false"); + SendResponse(false); + return; + } + } + + SendResponse(true); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_command_request.cc b/src/components/application_manager/src/commands/mobile/delete_command_request.cc new file mode 100644 index 0000000000..3c3ee88203 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_command_request.cc @@ -0,0 +1,183 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_command_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +DeleteCommandRequest::DeleteCommandRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message), + is_ui_send_(false), + is_vr_send_(false), + is_ui_received_(false), + is_vr_received_(false), + ui_result_(hmi_apis::Common_Result::INVALID_ENUM), + vr_result_(hmi_apis::Common_Result::INVALID_ENUM) { +} + +DeleteCommandRequest::~DeleteCommandRequest() { +} + +void DeleteCommandRequest::Run() { + LOG4CXX_INFO(logger_, "DeleteCommandRequest::Run"); + + ApplicationSharedPtr application = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!application) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + smart_objects::SmartObject* command = application->FindCommand( + (*message_)[strings::msg_params][strings::cmd_id].asInt()); + + if (!command) { + SendResponse(false, mobile_apis::Result::INVALID_ID); + LOG4CXX_ERROR(logger_, "Invalid ID"); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::cmd_id] = + (*message_)[strings::msg_params][strings::cmd_id]; + msg_params[strings::app_id] = application->app_id(); + + // we should specify amount of required responses in the 1st request + uint32_t chaining_counter = 0; + if ((*command).keyExists(strings::menu_params)) { + ++chaining_counter; + } + + if ((*command).keyExists(strings::vr_commands)) { + ++chaining_counter; + } + + if ((*command).keyExists(strings::menu_params)) { + is_ui_send_ = true; + + SendHMIRequest(hmi_apis::FunctionID::UI_DeleteCommand, &msg_params, true); + } + // check vr params + if ((*command).keyExists(strings::vr_commands)) { + is_vr_send_ = true; + + // VR params + msg_params[strings::grammar_id] = application->get_grammar_id(); + msg_params[strings::type] = hmi_apis::Common_VRCommandType::Command; + SendHMIRequest(hmi_apis::FunctionID::VR_DeleteCommand, &msg_params, true); + } +} + +void DeleteCommandRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "DeleteCommandRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_DeleteCommand: { + LOG4CXX_INFO(logger_, "Received UI_DeleteCommand event"); + is_ui_received_ = true; + ui_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + break; + } + case hmi_apis::FunctionID::VR_DeleteCommand: { + LOG4CXX_INFO(logger_, "Received VR_DeleteCommand event"); + is_vr_received_ = true; + vr_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + return; + } + } + + if (!IsPendingResponseExist()) { + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + smart_objects::SmartObject* command = application->FindCommand( + (*message_)[strings::msg_params][strings::cmd_id].asInt()); + + if (command) { + mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM; + + bool result = ((hmi_apis::Common_Result::SUCCESS == ui_result_) && + (hmi_apis::Common_Result::SUCCESS == vr_result_)) || + ((hmi_apis::Common_Result::SUCCESS == ui_result_) && + (hmi_apis::Common_Result::INVALID_ENUM == vr_result_)) || + ((hmi_apis::Common_Result::INVALID_ENUM == ui_result_) && + (hmi_apis::Common_Result::SUCCESS == vr_result_)); + + if (result) { + application->RemoveCommand( + (*message_)[strings::msg_params][strings::cmd_id].asInt()); + } + + if (!result && (hmi_apis::Common_Result::REJECTED == ui_result_)) { + result_code = static_cast<mobile_apis::Result::eType>(vr_result_); + } else { + result_code = static_cast<mobile_apis::Result::eType>( + std::max(ui_result_, vr_result_)); + } + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + } + } +} + +bool DeleteCommandRequest::IsPendingResponseExist() { + return is_ui_send_ != is_ui_received_ || is_vr_send_ != is_vr_received_; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_command_response.cc b/src/components/application_manager/src/commands/mobile/delete_command_response.cc new file mode 100644 index 0000000000..812e587430 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_command_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_command_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +DeleteCommandResponse::DeleteCommandResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +DeleteCommandResponse::~DeleteCommandResponse() { +} + +void DeleteCommandResponse::Run() { + LOG4CXX_INFO(logger_, "DeleteCommandResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_file_request.cc b/src/components/application_manager/src/commands/mobile/delete_file_request.cc new file mode 100644 index 0000000000..ca5a4395fc --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_file_request.cc @@ -0,0 +1,115 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_file_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "config_profile/profile.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +DeleteFileRequest::DeleteFileRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +DeleteFileRequest::~DeleteFileRequest() { +} + +void DeleteFileRequest::Run() { + LOG4CXX_INFO(logger_, "DeleteFileRequest::Run"); + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + if ((mobile_api::HMILevel::HMI_NONE == application->hmi_level()) && + (profile::Profile::instance()->delete_file_in_none() <= + application->delete_file_in_none_count())) { + // If application is in the HMI_NONE level the quantity of allowed + // DeleteFile request is limited by the configuration profile + LOG4CXX_ERROR(logger_, "Too many requests from the app with HMILevel HMI_NONE "); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + const std::string& sync_file_name = + (*message_)[strings::msg_params][strings::sync_file_name].asString(); + + std::string full_file_path = + profile::Profile::instance()->app_storage_folder() + "/"; + full_file_path += application->folder_name(); + full_file_path += "/"; + full_file_path += sync_file_name; + + if (file_system::FileExists(full_file_path)) { + if (file_system::DeleteFile(full_file_path)) { + const AppFile* file = application->GetFile(full_file_path); + if (file) { + SendFileRemovedNotification(file); + } + + application->DeleteFile(full_file_path); + application->increment_delete_file_in_none_count(); + SendResponse(true, mobile_apis::Result::SUCCESS); + } else { + SendResponse(false, mobile_apis::Result::GENERIC_ERROR); + } + } else { + SendResponse(false, mobile_apis::Result::INVALID_DATA); + } +} + +void DeleteFileRequest::SendFileRemovedNotification( + const AppFile* file) const { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::app_id] = connection_key(); + msg_params[strings::file_name] = file->file_name; + msg_params[strings::file_type] = file->file_type; + + CreateHMINotification( + hmi_apis::FunctionID::BasicCommunication_OnFileRemoved, msg_params); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_file_response.cc b/src/components/application_manager/src/commands/mobile/delete_file_response.cc new file mode 100644 index 0000000000..81470ccf6b --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_file_response.cc @@ -0,0 +1,69 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_file_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +DeleteFileResponse::DeleteFileResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +DeleteFileResponse::~DeleteFileResponse() { +} + +void DeleteFileResponse::Run() { + LOG4CXX_INFO(logger_, "DeleteFileResponse::Run"); + uint32_t app_id = (*message_)[strings::params][strings::connection_key] + .asUInt(); + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(app_id); + if (!app) { + LOG4CXX_ERROR(logger_, "Application not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + (*message_)[strings::msg_params][strings::space_available] = + static_cast<int32_t>( + ApplicationManagerImpl::instance()->GetAvailableSpaceForApp(app->name())); + SendResponse((*message_)[strings::msg_params][strings::success].asBool()); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_interaction_choice_set_request.cc b/src/components/application_manager/src/commands/mobile/delete_interaction_choice_set_request.cc new file mode 100644 index 0000000000..1fcd4b33d8 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_interaction_choice_set_request.cc @@ -0,0 +1,138 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_interaction_choice_set_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" +#include "application_manager/message_helper.h" +namespace application_manager { + +namespace commands { + +DeleteInteractionChoiceSetRequest::DeleteInteractionChoiceSetRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +DeleteInteractionChoiceSetRequest::~DeleteInteractionChoiceSetRequest() { +} + +void DeleteInteractionChoiceSetRequest::Run() { + LOG4CXX_INFO(logger_, "DeleteInteractionChoiceSetRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "No application associated with session key"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + const int32_t choise_set_id = + (*message_)[strings::msg_params] + [strings::interaction_choice_set_id].asInt(); + + if (!app->FindChoiceSet(choise_set_id)) { + LOG4CXX_ERROR_EXT(logger_, "INVALID_ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return; + } + + if (ChoiceSetInUse(app)) { + LOG4CXX_ERROR_EXT(logger_, "Choice set currently in use"); + SendResponse(false, mobile_apis::Result::IN_USE); + return; + } + SendVrDeleteCommand(app); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::interaction_choice_set_id] = choise_set_id; + msg_params[strings::app_id] = app->app_id(); + + app->RemoveChoiceSet(choise_set_id); + + SendResponse(true, mobile_apis::Result::SUCCESS); + /*CreateHMIRequest(hmi_apis::FunctionID::UI_DeleteInteractionChoiceSet, + msg_params, true);*/ +} + +bool DeleteInteractionChoiceSetRequest::ChoiceSetInUse(ApplicationConstSharedPtr app) { + if (app->is_perform_interaction_active()) { + // retrieve stored choice sets for perform interaction + const PerformChoiceSetMap& choice_set_map = app + ->performinteraction_choice_set_map(); + + PerformChoiceSetMap::const_iterator it = choice_set_map.begin(); + for (; choice_set_map.end() != it; ++it) { + if (it->first + == (*message_)[strings::msg_params] + [strings::interaction_choice_set_id].asUInt()) { + LOG4CXX_ERROR_EXT(logger_, + "DeleteInteractionChoiceSetRequest::ChoiceSetInUse"); + return true; + } + } + } + return false; +} + +void DeleteInteractionChoiceSetRequest::SendVrDeleteCommand( + application_manager::ApplicationSharedPtr app) { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::SendVrDeleteCommand"); + + smart_objects::SmartObject* choice_set = + app->FindChoiceSet((*message_)[strings::msg_params] + [strings::interaction_choice_set_id].asInt()); + + if (choice_set) { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::type] = hmi_apis::Common_VRCommandType::Choice; + msg_params[strings::grammar_id] = (*choice_set)[strings::grammar_id]; + choice_set = &((*choice_set)[strings::choice_set]); + for (uint32_t i = 0; i < (*choice_set).length() ; ++i) { + msg_params[strings::cmd_id] = (*choice_set)[i][strings::choice_id]; + SendHMIRequest(hmi_apis::FunctionID::VR_DeleteCommand, &msg_params); + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_interaction_choice_set_response.cc b/src/components/application_manager/src/commands/mobile/delete_interaction_choice_set_response.cc new file mode 100644 index 0000000000..d260add7cc --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_interaction_choice_set_response.cc @@ -0,0 +1,77 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_interaction_choice_set_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +DeleteInteractionChoiceSetResponse::DeleteInteractionChoiceSetResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +DeleteInteractionChoiceSetResponse::~DeleteInteractionChoiceSetResponse() { +} + +void DeleteInteractionChoiceSetResponse::Run() { + LOG4CXX_INFO(logger_, "DeleteInteractionChoiceSetResponse::Run"); + + // check if response false + if (true == (*message_)[strings::msg_params].keyExists(strings::success)) { + if ((*message_)[strings::msg_params][strings::success].asBool() == false) { + LOG4CXX_ERROR(logger_, "Success = false"); + SendResponse(false); + return; + } + } + + const int32_t code = + (*message_)[strings::msg_params][strings::result_code].asInt(); + + if (hmi_apis::Common_Result::SUCCESS == code) { + SendResponse(true); + } else { + // TODO(DK): Some logic + SendResponse(false); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_sub_menu_request.cc b/src/components/application_manager/src/commands/mobile/delete_sub_menu_request.cc new file mode 100644 index 0000000000..d91e742687 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_sub_menu_request.cc @@ -0,0 +1,179 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_sub_menu_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +DeleteSubMenuRequest::DeleteSubMenuRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +DeleteSubMenuRequest::~DeleteSubMenuRequest() { +} + +void DeleteSubMenuRequest::Run() { + LOG4CXX_INFO(logger_, "DeleteSubMenuRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + if (!app->FindSubMenu( + (*message_)[strings::msg_params][strings::menu_id].asInt())) { + SendResponse(false, mobile_apis::Result::INVALID_ID); + LOG4CXX_ERROR(logger_, "Invalid ID"); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::menu_id] = + (*message_)[strings::msg_params][strings::menu_id]; + msg_params[strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::UI_DeleteSubMenu, &msg_params, true); +} + +void DeleteSubMenuRequest::DeleteSubMenuVRCommands(ApplicationConstSharedPtr app) { + LOG4CXX_INFO(logger_, "DeleteSubMenuRequest::DeleteSubMenuVRCommands"); + + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator it = commands.begin(); + + for (; commands.end() != it; ++it) { + + if (!(*it->second).keyExists(strings::vr_commands)) { + continue; + } + + if ((*message_)[strings::msg_params][strings::menu_id].asInt() + == (*it->second)[strings::menu_params] + [hmi_request::parent_id].asInt()) { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::cmd_id] = (*it->second)[strings::cmd_id].asInt(); + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::grammar_id] = app->get_grammar_id(); + msg_params[strings::type] = hmi_apis::Common_VRCommandType::Command; + + SendHMIRequest(hmi_apis::FunctionID::VR_DeleteCommand, &msg_params); + } + } +} + +void DeleteSubMenuRequest::DeleteSubMenuUICommands(ApplicationSharedPtr const app) { + LOG4CXX_INFO(logger_, "DeleteSubMenuRequest::DeleteSubMenuUICommands"); + + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator it = commands.begin(); + + while (commands.end() != it) { + + if (!(*it->second).keyExists(strings::menu_params)) { + continue; + } + + if ((*message_)[strings::msg_params][strings::menu_id].asInt() + == (*it->second)[strings::menu_params] + [hmi_request::parent_id].asInt()) { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::cmd_id] = (*it->second)[strings::cmd_id].asInt(); + + app->RemoveCommand((*it->second)[strings::cmd_id].asInt()); + + it = commands.begin(); // Can not relay on + // iterators after erase was called + + SendHMIRequest(hmi_apis::FunctionID::UI_DeleteCommand, &msg_params); + } else { + ++it; + } + } +} + +void DeleteSubMenuRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "DeleteSubMenuRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_DeleteSubMenu: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + if (result) { + // delete sub menu items from SDL and HMI + DeleteSubMenuVRCommands(application); + DeleteSubMenuUICommands(application); + application->RemoveSubMenu( + (*message_)[strings::msg_params][strings::menu_id].asInt()); + } + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/delete_sub_menu_response.cc b/src/components/application_manager/src/commands/mobile/delete_sub_menu_response.cc new file mode 100644 index 0000000000..0a25a11610 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/delete_sub_menu_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/delete_sub_menu_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +DeleteSubMenuResponse::DeleteSubMenuResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +DeleteSubMenuResponse::~DeleteSubMenuResponse() { +} + +void DeleteSubMenuResponse::Run() { + LOG4CXX_INFO(logger_, "DeleteSubMenuResponse::Run"); + + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/diagnostic_message_request.cc b/src/components/application_manager/src/commands/mobile/diagnostic_message_request.cc new file mode 100644 index 0000000000..75016c05fb --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/diagnostic_message_request.cc @@ -0,0 +1,94 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/diagnostic_message_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +DiagnosticMessageRequest::DiagnosticMessageRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +DiagnosticMessageRequest::~DiagnosticMessageRequest() { +} + +void DiagnosticMessageRequest::Run() { + LOG4CXX_INFO(logger_, "DiagnosticMessageRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + connection_key()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "An application is not registered."); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + // Add app_id for HMI request + (*message_)[strings::msg_params][strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::VehicleInfo_DiagnosticMessage, + &(*message_)[strings::msg_params], true); + +} + +void DiagnosticMessageRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "DiagnosticMessageRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::VehicleInfo_DiagnosticMessage: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/diagnostic_message_response.cc b/src/components/application_manager/src/commands/mobile/diagnostic_message_response.cc new file mode 100644 index 0000000000..2a8b234fff --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/diagnostic_message_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/diagnostic_message_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +DiagnosticMessageResponse::DiagnosticMessageResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +DiagnosticMessageResponse::~DiagnosticMessageResponse() { +} + +void DiagnosticMessageResponse::Run() { + LOG4CXX_INFO(logger_, "DiagnosticMessageResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/dial_number_request.cc b/src/components/application_manager/src/commands/mobile/dial_number_request.cc new file mode 100644 index 0000000000..140f43128d --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/dial_number_request.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/dial_number_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +DialNumberRequest::DialNumberRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +DialNumberRequest::~DialNumberRequest() { +} + +void DialNumberRequest::Run() { + LOG4CXX_INFO(logger_, "DialNumberRequest::Run"); + + SendResponse(false, mobile_apis::Result::UNSUPPORTED_REQUEST); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/end_audio_pass_thru_request.cc b/src/components/application_manager/src/commands/mobile/end_audio_pass_thru_request.cc new file mode 100644 index 0000000000..eedc9f813e --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/end_audio_pass_thru_request.cc @@ -0,0 +1,88 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/end_audio_pass_thru_request.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +EndAudioPassThruRequest::EndAudioPassThruRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +EndAudioPassThruRequest::~EndAudioPassThruRequest() { +} + +void EndAudioPassThruRequest::Run() { + LOG4CXX_INFO(logger_, "EndAudioPassThruRequest::Run"); + + SendHMIRequest(hmi_apis::FunctionID::UI_EndAudioPassThru, NULL, true); +} + +void EndAudioPassThruRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "EndAudioPassThruRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_EndAudioPassThru: { + mobile_apis::Result::eType mobile_code = + GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asUInt())); + + bool result = mobile_apis::Result::SUCCESS == mobile_code; + + if (result) { + bool ended_successfully = + ApplicationManagerImpl::instance()->end_audio_pass_thru(); + if (ended_successfully) { + ApplicationManagerImpl::instance()->StopAudioPassThru( + connection_key()); + } + } + + SendResponse(result, mobile_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/end_audio_pass_thru_response.cc b/src/components/application_manager/src/commands/mobile/end_audio_pass_thru_response.cc new file mode 100644 index 0000000000..128d921f9f --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/end_audio_pass_thru_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/end_audio_pass_thru_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +EndAudioPassThruResponse::EndAudioPassThruResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +EndAudioPassThruResponse::~EndAudioPassThruResponse() { +} + +void EndAudioPassThruResponse::Run() { + LOG4CXX_INFO(logger_, "EndAudioPassThruResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/generic_response.cc b/src/components/application_manager/src/commands/mobile/generic_response.cc new file mode 100644 index 0000000000..69c841b2f1 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/generic_response.cc @@ -0,0 +1,65 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/generic_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +void GenericResponse::Run() { + /*NsSmartDeviceLink::NsSmartObjects::SmartObject response; + + response[strings::params][strings::correlation_id] = + (*message_)[strings::params][strings::correlation_id]; + response[strings::params][strings::protocol_version] = + (*message_)[strings::params][strings::protocol_version]; + response[strings::params][strings::connection_key] = + (*message_)[strings::params][strings::connection_key]; + + response[strings::msg_params][strings::success] = false; + */ + + (*message_)[strings::params][strings::message_type] = MessageType::kResponse; + (*message_)[strings::msg_params][strings::success] = false; + (*message_)[strings::msg_params][strings::result_code] = + mobile_apis::Result::INVALID_DATA; + + SendResponse(false); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/get_dtcs_request.cc b/src/components/application_manager/src/commands/mobile/get_dtcs_request.cc new file mode 100644 index 0000000000..9a81f94db1 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/get_dtcs_request.cc @@ -0,0 +1,108 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/get_dtcs_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +GetDTCsRequest::GetDTCsRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +GetDTCsRequest::~GetDTCsRequest() { +} + +void GetDTCsRequest::Run() { + LOG4CXX_INFO(logger_, "GetDTCsRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (mobile_api::HMILevel::HMI_NONE == app->hmi_level()) { + LOG4CXX_ERROR(logger_, "App has not been activated"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::ecu_name] = + (*message_)[strings::msg_params][strings::ecu_name]; + + if ((*message_)[strings::msg_params].keyExists(strings::dtc_mask)) { + msg_params[strings::dtc_mask] = + (*message_)[strings::msg_params][strings::dtc_mask]; + } + + msg_params[strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::VehicleInfo_GetDTCs, &msg_params, true); +} + +void GetDTCsRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "GetDTCsRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::VehicleInfo_GetDTCs: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/get_dtcs_response.cc b/src/components/application_manager/src/commands/mobile/get_dtcs_response.cc new file mode 100644 index 0000000000..2ed7a92952 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/get_dtcs_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/get_dtcs_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +GetDTCsResponse::GetDTCsResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +GetDTCsResponse::~GetDTCsResponse() { +} + +void GetDTCsResponse::Run() { + LOG4CXX_INFO(logger_, "GetDTCsResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/get_vehicle_data_request.cc b/src/components/application_manager/src/commands/mobile/get_vehicle_data_request.cc new file mode 100644 index 0000000000..a3d08a15ff --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/get_vehicle_data_request.cc @@ -0,0 +1,302 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string> +#include "application_manager/commands/mobile/get_vehicle_data_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +namespace str = strings; + +#ifdef HMI_DBUS_API +GetVehicleDataRequest::GetVehicleDataRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +GetVehicleDataRequest::~GetVehicleDataRequest() { +} + +void GetVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "GetVehicleDataRequest::Run"); + + int32_t app_id = (*message_)[strings::params][strings::connection_key].asUInt(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (mobile_api::HMILevel::HMI_NONE == app->hmi_level()) { + LOG4CXX_ERROR(logger_, "app in HMI level HMI_NONE"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + + for (; vehicle_data.end() != it; ++it) { + if (true == (*message_)[str::msg_params].keyExists(it->first) + && true == (*message_)[str::msg_params][it->first].asBool()) { + SendRequestsToHmi(app->app_id()); + return; + } + } + + SendResponse(false, mobile_apis::Result::INVALID_DATA); +} + +namespace { + struct Subrequest { + hmi_apis::FunctionID::eType func_id; + const char* str; + }; + Subrequest subrequests[] = { + { hmi_apis::FunctionID::VehicleInfo_GetGpsData, str::gps}, + { hmi_apis::FunctionID::VehicleInfo_GetSpeed, str::speed}, + { hmi_apis::FunctionID::VehicleInfo_GetRpm, str::rpm}, + { hmi_apis::FunctionID::VehicleInfo_GetFuelLevel, str::fuel_level}, + { hmi_apis::FunctionID::VehicleInfo_GetFuelLevelState, str::fuel_level_state}, + { hmi_apis::FunctionID::VehicleInfo_GetInstantFuelConsumption, str::instant_fuel_consumption}, + { hmi_apis::FunctionID::VehicleInfo_GetExternalTemperature, str::external_temp}, + { hmi_apis::FunctionID::VehicleInfo_GetVin, str::vin}, + { hmi_apis::FunctionID::VehicleInfo_GetPrndl, str::prndl}, + { hmi_apis::FunctionID::VehicleInfo_GetTirePressure, str::tire_pressure}, + { hmi_apis::FunctionID::VehicleInfo_GetOdometer, str::odometer}, + { hmi_apis::FunctionID::VehicleInfo_GetBeltStatus, str::belt_status}, + { hmi_apis::FunctionID::VehicleInfo_GetBodyInformation, str::body_information}, + { hmi_apis::FunctionID::VehicleInfo_GetDeviceStatus, str::device_status}, + { hmi_apis::FunctionID::VehicleInfo_GetDriverBraking, str::driver_braking}, + { hmi_apis::FunctionID::VehicleInfo_GetWiperStatus, str::wiper_status}, + { hmi_apis::FunctionID::VehicleInfo_GetHeadLampStatus, str::head_lamp_status}, + { hmi_apis::FunctionID::VehicleInfo_GetEngineTorque, str::engine_torque}, + { hmi_apis::FunctionID::VehicleInfo_GetAccPedalPosition, str::acc_pedal_pos}, + { hmi_apis::FunctionID::VehicleInfo_GetSteeringWheelAngle, str::steering_wheel_angle}, + { hmi_apis::FunctionID::VehicleInfo_GetECallInfo, str::e_call_info}, + { hmi_apis::FunctionID::VehicleInfo_GetAirbagStatus, str::airbag_status}, + { hmi_apis::FunctionID::VehicleInfo_GetEmergencyEvent, str::emergency_event}, + { hmi_apis::FunctionID::VehicleInfo_GetClusterModeStatus, str::cluster_mode_status}, + { hmi_apis::FunctionID::VehicleInfo_GetMyKey, str::my_key}, + }; +} + +void GetVehicleDataRequest::SendRequestsToHmi(const int32_t app_id) { + smart_objects::SmartObject msg_params(smart_objects::SmartType_Map); + msg_params[strings::app_id] = app_id; + + for (size_t i = 0; i < sizeof(subrequests) / sizeof(subrequests[0]); ++i) { + const Subrequest& sr = subrequests[i]; + if (true == (*message_)[str::msg_params].keyExists(sr.str) + && true == (*message_)[str::msg_params][sr.str].asBool()) { + HmiRequest hmi_request; + hmi_request.str = sr.str; + hmi_request.func_id = sr.func_id; + hmi_request.complete = false; + hmi_requests_.push_back(hmi_request); + } + } + + LOG4CXX_INFO(logger_, + hmi_requests_.size() << " requests are going to be sent to HMI"); + + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + SendHMIRequest(it->func_id, &msg_params, true); + } +} + +void GetVehicleDataRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "GetVehicleDataRequest::on_event " << event.id()); + + const smart_objects::SmartObject& message = event.smart_object(); + + for (HmiRequests::iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + HmiRequest & hmi_request = *it; + if (hmi_request.func_id == event.id()) { + hmi_request.status = + static_cast<hmi_apis::Common_Result::eType>(message[strings::params][hmi_response::code] + .asInt()); + if (hmi_apis::Common_Result::SUCCESS == hmi_request.status) + hmi_request.value = message[str::msg_params][hmi_request.str]; + hmi_request.complete = true; + break; + } + } + + bool all_complete = true; + bool any_arg_success = false; + mobile_api::Result::eType status = mobile_api::Result::eType::SUCCESS; + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + if (!it->complete) { + all_complete = false; + break; + } + if (hmi_apis::Common_Result::SUCCESS != it->status) { + if (mobile_api::Result::SUCCESS == status) { + status = static_cast<mobile_apis::Result::eType>(it->status); + } else if (status + != static_cast<mobile_apis::Result::eType>(it->status)) { + status = mobile_api::Result::eType::GENERIC_ERROR; + } + LOG4CXX_TRACE(logger_, "Status from HMI: " << it->status << ", so response status become " << status); + } else { + any_arg_success = true; + } + } + + if (all_complete) { + smart_objects::SmartObject response_params(smart_objects::SmartType_Map); + if (any_arg_success) { + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + response_params[it->str] = it->value; + } + } + LOG4CXX_INFO( + logger_, "All HMI requests are complete"); + const char *info = NULL; + std::string error_message; + if (true == message[strings::params].keyExists(strings::error_msg)) { + error_message = message[strings::params][strings::error_msg].asString(); + info = error_message.c_str(); + } + SendResponse( any_arg_success, status, info, &response_params); + } +} +#else +GetVehicleDataRequest::GetVehicleDataRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +GetVehicleDataRequest::~GetVehicleDataRequest() { +} + +void GetVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "GetVehicleDataRequest::Run"); + + int32_t app_id = (*message_)[strings::params][strings::connection_key].asUInt(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (mobile_api::HMILevel::HMI_NONE == app->hmi_level()) { + LOG4CXX_ERROR(logger_, "app in HMI level HMI_NONE."); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + if (app->IsCommandLimitsExceeded( + static_cast<mobile_apis::FunctionID::eType>(function_id()), + application_manager::TLimitSource::CONFIG_FILE)) { + LOG4CXX_ERROR(logger_, "GetVehicleData frequency is too high."); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app->app_id(); + const uint32_t min_length_msg_params = 1; + for (; vehicle_data.end() != it; ++it) { + if (true == (*message_)[str::msg_params].keyExists(it->first) + && true == (*message_)[str::msg_params][it->first].asBool()) { + msg_params[it->first] = (*message_)[strings::msg_params][it->first]; + } + } + if (msg_params.length() > min_length_msg_params) { + SendHMIRequest(hmi_apis::FunctionID::VehicleInfo_GetVehicleData, + &msg_params, true); + return; + } else if (HasDisallowedParams()) { + SendResponse(false, mobile_apis::Result::DISALLOWED); + } else { + SendResponse(false, mobile_apis::Result::INVALID_DATA); + } +} + +void GetVehicleDataRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "GetVehicleDataRequest::on_event"); + smart_objects::SmartObject message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::VehicleInfo_GetVehicleData: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + bool result = false; + if (mobile_apis::Result::SUCCESS == result_code || + (hmi_apis::Common_Result::DATA_NOT_AVAILABLE == + static_cast<hmi_apis::Common_Result::eType>(result_code) + && message[strings::msg_params].length() > 1)) { + result = true; + } + const char *info = NULL; + std::string error_message; + if (true == + message[strings::msg_params].keyExists(hmi_response::method)) { + message[strings::msg_params].erase(hmi_response::method); + } + if (true == message[strings::params].keyExists(strings::error_msg)) { + error_message = message[strings::params][strings::error_msg].asString(); + info = error_message.c_str(); + } + SendResponse(result, result_code, info, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +#endif // #ifdef HMI_DBUS_API + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/get_vehicle_data_response.cc b/src/components/application_manager/src/commands/mobile/get_vehicle_data_response.cc new file mode 100644 index 0000000000..d9087fdc61 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/get_vehicle_data_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/get_vehicle_data_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +GetVehicleDataResponse::GetVehicleDataResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +GetVehicleDataResponse::~GetVehicleDataResponse() { +} + +void GetVehicleDataResponse::Run() { + LOG4CXX_INFO(logger_, "GetVehicleDataResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/list_files_request.cc b/src/components/application_manager/src/commands/mobile/list_files_request.cc new file mode 100644 index 0000000000..d0fa71d466 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/list_files_request.cc @@ -0,0 +1,97 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/list_files_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "config_profile/profile.h" +#include "application_manager/mobile_command_factory.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +ListFilesRequest::ListFilesRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +ListFilesRequest::~ListFilesRequest() { +} + +void ListFilesRequest::Run() { + LOG4CXX_INFO(logger_, "ListFilesRequest::Run"); + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!application) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + if ((mobile_api::HMILevel::HMI_NONE == application->hmi_level()) && + (profile::Profile::instance()->list_files_in_none() <= + application->list_files_in_none_count())) { + // If application is in the HMI_NONE level the quantity of allowed + // DeleteFile request is limited by the configuration profile + LOG4CXX_ERROR(logger_, "Too many requests from the app with HMILevel HMI_NONE "); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + application->increment_list_files_in_none_count(); + + (*message_)[strings::msg_params][strings::space_available] = + static_cast<int32_t>(ApplicationManagerImpl::instance()-> + GetAvailableSpaceForApp(application->folder_name())); + int32_t i = 0; + const AppFilesMap& app_files = application->getAppFiles(); + for (AppFilesMap::const_iterator it = app_files.begin(); + it != app_files.end(); ++it) { + //In AppFile to application stored full path to file. In message required + //to write only name file. + //Plus one required for move to next letter after '/'. + (*message_)[strings::msg_params][strings::filenames][i++] = + it->first.substr(it->first.find_last_of('/') + 1); + } + (*message_)[strings::params][strings::message_type] = + application_manager::MessageType::kResponse; + SendResponse(true, mobile_apis::Result::SUCCESS, NULL, + &(*message_)[strings::msg_params]); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/list_files_response.cc b/src/components/application_manager/src/commands/mobile/list_files_response.cc new file mode 100644 index 0000000000..6ffbec1ac4 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/list_files_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/list_files_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +ListFilesResponse::ListFilesResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +ListFilesResponse::~ListFilesResponse() { +} + +void ListFilesResponse::Run() { + LOG4CXX_INFO(logger_, "ListFilesResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_app_interface_unregistered_notification.cc b/src/components/application_manager/src/commands/mobile/on_app_interface_unregistered_notification.cc new file mode 100644 index 0000000000..ebd0d6aac1 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_app_interface_unregistered_notification.cc @@ -0,0 +1,55 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_app_interface_unregistered_notification.h" +#include "application_manager/message.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { +namespace commands { + +OnAppInterfaceUnregisteredNotification::OnAppInterfaceUnregisteredNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnAppInterfaceUnregisteredNotification::~OnAppInterfaceUnregisteredNotification() { +} + +void OnAppInterfaceUnregisteredNotification::Run() { + LOG4CXX_INFO(logger_, "OnAppInterfaceUnregisteredNotification::Run"); + + SendNotification(); +} +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_audio_pass_thru_notification.cc b/src/components/application_manager/src/commands/mobile/on_audio_pass_thru_notification.cc new file mode 100644 index 0000000000..2515f591b1 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_audio_pass_thru_notification.cc @@ -0,0 +1,53 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_audio_pass_thru_notification.h" + +namespace application_manager { +namespace commands { + +OnAudioPassThruNotification::OnAudioPassThruNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnAudioPassThruNotification::~OnAudioPassThruNotification() { +} + +void OnAudioPassThruNotification::Run() { + LOG4CXX_INFO(logger_, "OnAudioPassThruNotification::Run"); + + SendNotification(); +} +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_button_event_notification.cc b/src/components/application_manager/src/commands/mobile/on_button_event_notification.cc new file mode 100644 index 0000000000..55b9b8818d --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_button_event_notification.cc @@ -0,0 +1,163 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_button_event_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnButtonEventNotification::OnButtonEventNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnButtonEventNotification::~OnButtonEventNotification() { +} + +void OnButtonEventNotification::Run() { + LOG4CXX_INFO(logger_, "OnButtonEventNotification::Run"); + + const uint32_t btn_id = + static_cast<uint32_t>( + (*message_)[strings::msg_params][hmi_response::button_name].asInt()); + + // CUSTOM_BUTTON notification + if (static_cast<uint32_t>(mobile_apis::ButtonName::CUSTOM_BUTTON) == btn_id) { + // app_id is mandatory for CUSTOM_BUTTON notification + if (false == (*message_)[strings::msg_params].keyExists(strings::app_id)) { + LOG4CXX_ERROR_EXT(logger_, "CUSTOM_BUTTON OnButtonEvent without app_id."); + return; + } + + // custom_button_id is mandatory for CUSTOM_BUTTON notification + if (false == (*message_)[strings::msg_params].keyExists( + hmi_response::custom_button_id)) { + LOG4CXX_ERROR_EXT(logger_, + "CUSTOM_BUTTON OnButtonEvent without custom_button_id."); + return; + } + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::msg_params][strings::app_id].asUInt()); + + if (false == app.valid()) { + LOG4CXX_ERROR_EXT(logger_, "Application doesn't exist."); + return; + } + + uint32_t custom_btn_id = 0; + custom_btn_id = (*message_)[strings::msg_params] + [hmi_response::custom_button_id].asUInt(); + + if (false == app->IsSubscribedToSoftButton(custom_btn_id)) { + LOG4CXX_ERROR_EXT(logger_, + "Application doesn't subscribed to this custom_button_id."); + return; + } + + SendButtonEvent(app); + return; + } + + const std::vector<ApplicationSharedPtr>& subscribedApps = + ApplicationManagerImpl::instance()->applications_by_button(btn_id); + + std::vector<ApplicationSharedPtr>::const_iterator it = subscribedApps.begin(); + for (; subscribedApps.end() != it; ++it) { + ApplicationSharedPtr subscribed_app = *it; + if (!subscribed_app) { + LOG4CXX_WARN_EXT(logger_, "Null pointer to subscribed app."); + continue; + } + + //Send ButtonEvent notification only in HMI_FULL or HMI_LIMITED mode + if ((mobile_api::HMILevel::HMI_FULL != subscribed_app->hmi_level()) && + (mobile_api::HMILevel::HMI_LIMITED != subscribed_app->hmi_level())) { + LOG4CXX_WARN_EXT(logger_, "OnButtonEvent in HMI_BACKGROUND or NONE"); + continue; + } + + //Send ButtonEvent notification for OK button only in HMI_FULL mode + if ((static_cast<uint32_t>(mobile_apis::ButtonName::OK) == btn_id) && + (mobile_api::HMILevel::HMI_FULL != subscribed_app->hmi_level())) { + continue; + } + + SendButtonEvent(subscribed_app); + } +} + +void OnButtonEventNotification::SendButtonEvent(ApplicationConstSharedPtr app) { + smart_objects::SmartObject* on_btn_event = new smart_objects::SmartObject(); + + if (!on_btn_event) { + LOG4CXX_ERROR_EXT(logger_, "OnButtonEvent NULL pointer"); + return; + } + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "OnButtonEvent NULL pointer"); + return; + } + + (*on_btn_event)[strings::params][strings::connection_key] = app->app_id(); + + (*on_btn_event)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnButtonEventID); + + (*on_btn_event)[strings::msg_params][strings::button_name] = + (*message_)[strings::msg_params][hmi_response::button_name]; + (*on_btn_event)[strings::msg_params][strings::button_event_mode] = + (*message_)[strings::msg_params][hmi_response::button_mode]; + + if ((*message_)[strings::msg_params].keyExists( + hmi_response::custom_button_id)) { + (*on_btn_event)[strings::msg_params][strings::custom_button_id] = + (*message_)[strings::msg_params][strings::custom_button_id]; + } + + message_.reset(on_btn_event); + SendNotification(); +} + +} // namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_button_press_notification.cc b/src/components/application_manager/src/commands/mobile/on_button_press_notification.cc new file mode 100644 index 0000000000..cfafc7af1c --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_button_press_notification.cc @@ -0,0 +1,163 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_button_press_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnButtonPressNotification::OnButtonPressNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnButtonPressNotification::~OnButtonPressNotification() { +} + +void OnButtonPressNotification::Run() { + LOG4CXX_INFO(logger_, "OnButtonPressNotification::Run"); + + const uint32_t btn_id = + static_cast<uint32_t>( + (*message_)[strings::msg_params][hmi_response::button_name].asInt()); + + // CUSTOM_BUTTON notification + if (static_cast<uint32_t>(mobile_apis::ButtonName::CUSTOM_BUTTON) == btn_id) { + // app_id is mandatory for CUSTOM_BUTTON notification + if (false == (*message_)[strings::msg_params].keyExists(strings::app_id)) { + LOG4CXX_ERROR_EXT(logger_, "CUSTOM_BUTTON OnButtonPress without app_id."); + return; + } + + // custom_button_id is mandatory for CUSTOM_BUTTON notification + if (false == (*message_)[strings::msg_params].keyExists( + hmi_response::custom_button_id)) { + LOG4CXX_ERROR_EXT(logger_, + "CUSTOM_BUTTON OnButtonPress without custom_button_id."); + return; + } + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::msg_params][strings::app_id].asUInt()); + + if (false == app.valid()) { + LOG4CXX_ERROR_EXT(logger_, "Application doesn't exist."); + return; + } + + uint32_t custom_btn_id = 0; + custom_btn_id = (*message_)[strings::msg_params] + [hmi_response::custom_button_id].asUInt(); + + if (false == app->IsSubscribedToSoftButton(custom_btn_id)) { + LOG4CXX_ERROR_EXT(logger_, + "Application doesn't subscribed to this custom_button_id."); + return; + } + + SendButtonPress(app); + return; + } + + const std::vector<ApplicationSharedPtr>& subscribedApps = + ApplicationManagerImpl::instance()->applications_by_button(btn_id); + + std::vector<ApplicationSharedPtr>::const_iterator it = subscribedApps.begin(); + for (; subscribedApps.end() != it; ++it) { + ApplicationSharedPtr subscribed_app = *it; + if (!subscribed_app) { + LOG4CXX_WARN_EXT(logger_, "Null pointer to subscribed app."); + continue; + } + + //Send ButtonPress notification only in HMI_FULL or HMI_LIMITED mode + if ((mobile_api::HMILevel::HMI_FULL != subscribed_app->hmi_level()) && + (mobile_api::HMILevel::HMI_LIMITED != subscribed_app->hmi_level())) { + LOG4CXX_WARN_EXT(logger_, "OnButtonPress in HMI_BACKGROUND or NONE"); + continue; + } + + //Send ButtonPress notification for OK button only in HMI_FULL mode + if ((static_cast<uint32_t>(mobile_apis::ButtonName::OK) == btn_id) && + (mobile_api::HMILevel::HMI_FULL != subscribed_app->hmi_level())) { + continue; + } + + SendButtonPress(subscribed_app); + } +} + +void OnButtonPressNotification::SendButtonPress(ApplicationConstSharedPtr app) { + smart_objects::SmartObject* on_btn_press = new smart_objects::SmartObject(); + + if (!on_btn_press) { + LOG4CXX_ERROR_EXT(logger_, "OnButtonPress NULL pointer"); + return; + } + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "OnButtonPress NULL pointer"); + return; + } + + (*on_btn_press)[strings::params][strings::connection_key] = app->app_id(); + + (*on_btn_press)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::eType::OnButtonPressID); + + (*on_btn_press)[strings::msg_params][strings::button_name] = + (*message_)[strings::msg_params][hmi_response::button_name]; + (*on_btn_press)[strings::msg_params][strings::button_press_mode] = + (*message_)[strings::msg_params][hmi_response::button_mode]; + + if ((*message_)[strings::msg_params].keyExists( + hmi_response::custom_button_id)) { + (*on_btn_press)[strings::msg_params][strings::custom_button_id] = + (*message_)[strings::msg_params][strings::custom_button_id]; + } + + message_.reset(on_btn_press); + SendNotification(); +} + +} // namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_command_notification.cc b/src/components/application_manager/src/commands/mobile/on_command_notification.cc new file mode 100644 index 0000000000..8342d05a45 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_command_notification.cc @@ -0,0 +1,80 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_command_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +OnCommandNotification::OnCommandNotification(const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnCommandNotification::~OnCommandNotification() { +} + +void OnCommandNotification::Run() { + LOG4CXX_INFO(logger_, "OnCommandNotification::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::msg_params][strings::app_id].asInt()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "No application associated with session key"); + return; + } + + const uint32_t cmd_id = (*message_)[strings::msg_params][strings::cmd_id] + .asUInt(); + + if (!app->FindCommand(cmd_id)) { + LOG4CXX_ERROR_EXT(logger_, + " No applications found for the command " << cmd_id); + return; + } + + (*message_)[strings::params][strings::connection_key] = app->app_id(); + // remove app_id from notification + if ((*message_)[strings::msg_params].keyExists(strings::app_id)) { + (*message_)[strings::msg_params].erase(strings::app_id); + } + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_driver_distraction_notification.cc b/src/components/application_manager/src/commands/mobile/on_driver_distraction_notification.cc new file mode 100644 index 0000000000..fc92c17e94 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_driver_distraction_notification.cc @@ -0,0 +1,63 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_driver_distraction_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnDriverDistractionNotification::OnDriverDistractionNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnDriverDistractionNotification::~OnDriverDistractionNotification() { +} + +void OnDriverDistractionNotification::Run() { + LOG4CXX_INFO(logger_, "OnDriverDistractionNotification::Run"); + + SendNotification(); +} + +} // namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_hash_change_notification.cc b/src/components/application_manager/src/commands/mobile/on_hash_change_notification.cc new file mode 100644 index 0000000000..b9ee1339bb --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_hash_change_notification.cc @@ -0,0 +1,75 @@ + +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_hash_change_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include <string> +#include <sstream> + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnHashChangeNotification::OnHashChangeNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnHashChangeNotification::~OnHashChangeNotification() { +} + +void OnHashChangeNotification::Run() { + LOG4CXX_INFO(logger_, "OnHashChangeNotification::Run"); + + (*message_)[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + + int32_t app_id; + app_id = (*message_)[strings::params][strings::connection_key].asInt(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + std::stringstream stream; + stream << app->curHash(); + (*message_)[strings::msg_params][strings::hash_id] = stream.str(); + SendNotification(); +} + +} //namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_hmi_status_notification.cc b/src/components/application_manager/src/commands/mobile/on_hmi_status_notification.cc new file mode 100644 index 0000000000..9c03c0f623 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_hmi_status_notification.cc @@ -0,0 +1,87 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_hmi_status_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "application_manager/message.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { +namespace commands { + +OnHMIStatusNotification::OnHMIStatusNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnHMIStatusNotification::~OnHMIStatusNotification() { +} + +void OnHMIStatusNotification::Run() { + LOG4CXX_INFO(logger_, "OnHMIStatusNotification::Run"); + + (*message_)[strings::params][strings::message_type] = static_cast<int32_t> ( + application_manager::MessageType::kNotification); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + if (!app.valid()) { + LOG4CXX_ERROR(logger_, "OnHMIStatusNotification application doesn't exist"); + return; + } + mobile_apis::HMILevel::eType hmi_level = + static_cast<mobile_apis::HMILevel::eType>( + (*message_)[strings::msg_params][strings::hmi_level].asInt()); + if ((mobile_apis::HMILevel::HMI_BACKGROUND == hmi_level) || + (mobile_apis::HMILevel::HMI_NONE == hmi_level)) { + if (!(app->tts_properties_in_none())) { + app->set_tts_properties_in_none(true); + LOG4CXX_INFO(logger_, "OnHMIStatusNotification::Send TTS GlobalProperties" + " with empty array to HMI"); + MessageHelper::SendTTSGlobalProperties(app, false); + } + } else if ((mobile_apis::HMILevel::HMI_FULL == hmi_level) || + (mobile_apis::HMILevel::HMI_LIMITED == hmi_level)) { + if (!(app->tts_properties_in_full())) { + app->set_tts_properties_in_full(true); + LOG4CXX_INFO(logger_, "OnHMIStatusNotification AddAppToTTSGlobalPropertiesList"); + ApplicationManagerImpl::instance()->AddAppToTTSGlobalPropertiesList( + app->app_id()); + } + } + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_keyboard_input_notification.cc b/src/components/application_manager/src/commands/mobile/on_keyboard_input_notification.cc new file mode 100644 index 0000000000..969885ab16 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_keyboard_input_notification.cc @@ -0,0 +1,73 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_keyboard_input_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnKeyBoardInputNotification::OnKeyBoardInputNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnKeyBoardInputNotification::~OnKeyBoardInputNotification() { +} + +void OnKeyBoardInputNotification::Run() { + LOG4CXX_INFO(logger_, "OnKeyBoardInputNotification::Run"); + + const std::vector<ApplicationSharedPtr>& applications = + ApplicationManagerImpl::instance()->applications_with_navi(); + + std::vector<ApplicationSharedPtr>::const_iterator it = applications.begin(); + for (; applications.end() != it; ++it) { + ApplicationSharedPtr app = *it; + if (mobile_apis::HMILevel::eType::HMI_NONE != app->hmi_level()) { + (*message_)[strings::params][strings::connection_key] = app->app_id(); + SendNotification(); + } + } +} + +} // namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_language_change_notification.cc b/src/components/application_manager/src/commands/mobile/on_language_change_notification.cc new file mode 100644 index 0000000000..f550df8748 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_language_change_notification.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_language_change_notification.h" + +namespace application_manager { + +namespace commands { + +OnLanguageChangeNotification::OnLanguageChangeNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnLanguageChangeNotification::~OnLanguageChangeNotification() { +} + +void OnLanguageChangeNotification::Run() { + LOG4CXX_INFO(logger_, "OnLanguageChangeNotification::Run"); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_permissions_change_notification.cc b/src/components/application_manager/src/commands/mobile/on_permissions_change_notification.cc new file mode 100644 index 0000000000..37c81085eb --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_permissions_change_notification.cc @@ -0,0 +1,61 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_permissions_change_notification.h" +#include "application_manager/message.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnPermissionsChangeNotification::OnPermissionsChangeNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnPermissionsChangeNotification::~OnPermissionsChangeNotification() { +} + +void OnPermissionsChangeNotification::Run() { + LOG4CXX_INFO(logger_, "OnPermissionsChangeNotification::Run"); + + (*message_)[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + + SendNotification(); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc b/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc new file mode 100644 index 0000000000..ebf98cd7e8 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_system_request_notification.cc @@ -0,0 +1,80 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_system_request_notification.h" +#include "interfaces/MOBILE_API.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnSystemRequestNotification::OnSystemRequestNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnSystemRequestNotification::~OnSystemRequestNotification() { +} + +void OnSystemRequestNotification::Run() { + LOG4CXX_INFO(logger_, "OnSystemRequestNotification::Run"); + + mobile_apis::RequestType::eType request_type = static_cast<mobile_apis::RequestType::eType> + ((*message_)[strings::msg_params][strings::request_type].asInt()); + + if (mobile_apis::RequestType::PROPRIETARY == request_type) { + std::string filename = (*message_)[strings::msg_params][strings::file_name].asString(); + + std::vector<uint8_t> binary_data; + file_system::ReadBinaryFile(filename, binary_data); + (*message_)[strings::params][strings::binary_data] = binary_data; + (*message_)[strings::msg_params][strings::file_type] = + mobile_apis::FileType::JSON; + } else if (mobile_apis::RequestType::HTTP == request_type) { + (*message_)[strings::msg_params][strings::file_type] = + mobile_apis::FileType::BINARY; + // TODO(PV): if needed for HTTP HMI case to be changed. + //(*message_)[strings::params][strings::binary_data] = binary_data; + } + + SendNotification(); +} + +} //namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_tbt_client_state_notification.cc b/src/components/application_manager/src/commands/mobile/on_tbt_client_state_notification.cc new file mode 100644 index 0000000000..05494c6144 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_tbt_client_state_notification.cc @@ -0,0 +1,72 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_tbt_client_state_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnTBTClientStateNotification::OnTBTClientStateNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnTBTClientStateNotification::~OnTBTClientStateNotification() { +} + +void OnTBTClientStateNotification::Run() { + LOG4CXX_INFO(logger_, "OnTBTClientStateNotification::Run"); + + (*message_)[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + + const std::vector<ApplicationSharedPtr>& applications = + ApplicationManagerImpl::instance()->applications_with_navi(); + + std::vector<ApplicationSharedPtr>::const_iterator it = applications.begin(); + for (; applications.end() != it; ++it) { + ApplicationSharedPtr app = *it; + if (mobile_apis::HMILevel::eType::HMI_NONE != app->hmi_level()) { + (*message_)[strings::params][strings::connection_key] = app->app_id(); + SendNotification(); + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_touch_event_notification.cc b/src/components/application_manager/src/commands/mobile/on_touch_event_notification.cc new file mode 100644 index 0000000000..250faa8f38 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_touch_event_notification.cc @@ -0,0 +1,72 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_touch_event_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +namespace mobile { + +OnTouchEventNotification::OnTouchEventNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnTouchEventNotification::~OnTouchEventNotification() { +} + +void OnTouchEventNotification::Run() { + LOG4CXX_INFO(logger_, "OnTouchEventNotification::Run"); + + const std::vector<ApplicationSharedPtr>& applications = + ApplicationManagerImpl::instance()->applications_with_navi(); + + std::vector<ApplicationSharedPtr>::const_iterator it = applications.begin(); + for (; applications.end() != it; ++it) { + ApplicationSharedPtr app = *it; + if (mobile_apis::HMILevel::HMI_FULL == app->hmi_level()) { + (*message_)[strings::params][strings::connection_key] = app->app_id(); + SendNotification(); + } + } +} + +} // namespace mobile + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/on_vehicle_data_notification.cc b/src/components/application_manager/src/commands/mobile/on_vehicle_data_notification.cc new file mode 100644 index 0000000000..420c42f30c --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/on_vehicle_data_notification.cc @@ -0,0 +1,89 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/on_vehicle_data_notification.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +OnVehicleDataNotification::OnVehicleDataNotification( + const MessageSharedPtr& message) + : CommandNotificationImpl(message) { +} + +OnVehicleDataNotification::~OnVehicleDataNotification() { +} + +void OnVehicleDataNotification::Run() { + LOG4CXX_INFO(logger_, "OnVehicleDataNotification::Run"); + + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + + for (; vehicle_data.end() != it; ++it) { + if (true == (*message_)[strings::msg_params].keyExists(it->first)) { + const std::vector<utils::SharedPtr<Application>>& applications = + ApplicationManagerImpl::instance()->IviInfoUpdated(it->second, + (*message_)[strings::msg_params][it->first].asInt()); + + std::vector<utils::SharedPtr<Application>>::const_iterator it = applications.begin(); + for (; applications.end() != it; ++it) { + utils::SharedPtr<Application> app = *it; + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "NULL pointer"); + continue; + } + + LOG4CXX_INFO( + logger_, + "Send OnVehicleData PRNDL notification to " << app->name() + << " application id " << app->app_id()); + + (*message_)[strings::params][strings::connection_key] = app->app_id(); + + SendNotification(); + } + + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc b/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc new file mode 100644 index 0000000000..c5f269fc48 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_request.cc @@ -0,0 +1,316 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include "application_manager/commands/mobile/perform_audio_pass_thru_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +namespace str = strings; + +PerformAudioPassThruRequest::PerformAudioPassThruRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message), + is_active_tts_speak_(false), + result_tts_speak_(mobile_apis::Result::SUCCESS) { + subscribe_on_event(hmi_apis::FunctionID::TTS_OnResetTimeout); +} + +PerformAudioPassThruRequest::~PerformAudioPassThruRequest() { +} + +void PerformAudioPassThruRequest::onTimeOut() { + LOG4CXX_INFO(logger_, "PerformAudioPassThruRequest::onTimeOut"); + + if (ApplicationManagerImpl::instance()->end_audio_pass_thru()) { + ApplicationManagerImpl::instance()->StopAudioPassThru(connection_key()); + } + + FinishTTSSpeak(); + + CommandRequestImpl::onTimeOut(); +} + +bool PerformAudioPassThruRequest::Init() { + default_timeout_ += (((*message_)[str::msg_params][str::max_duration].asInt())/1000); + return true; +} + +void PerformAudioPassThruRequest::Run() { + LOG4CXX_INFO(logger_, "PerformAudioPassThruRequest::Run"); + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR(logger_, "APPLICATION_NOT_REGISTERED"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (mobile_api::HMILevel::HMI_NONE == app->hmi_level()) { + LOG4CXX_ERROR(logger_, "application isn't activated"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming perform audio pass thru has contains \\t\\n \\\\t \\\\n" + " text contains only whitespace in initialPrompt"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if ((*message_)[str::msg_params].keyExists(str::initial_prompt) && + (0 < (*message_)[str::msg_params][str::initial_prompt].length())) { + // In case TTS Speak, subscribe on notification + SendSpeakRequest(); + SendPerformAudioPassThruRequest(); + } else { + SendPerformAudioPassThruRequest(); + SendRecordStartNotification(); + StartMicrophoneRecording(); + } +} + +void PerformAudioPassThruRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "PerformAudioPassThruRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_PerformAudioPassThru: { + + mobile_apis::Result::eType mobile_code = + GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asUInt())); + + // in case perform audio is started by other request skip stopping + if (mobile_apis::Result::REJECTED == mobile_code) { + LOG4CXX_ERROR(logger_, "Request was rejected"); + SendResponse(false, mobile_code, NULL, &(message[strings::msg_params])); + return; + } + + if (ApplicationManagerImpl::instance()->end_audio_pass_thru()) { + ApplicationManagerImpl::instance()->StopAudioPassThru(connection_key()); + } + + FinishTTSSpeak(); + + std::string return_info; + bool result = mobile_apis::Result::SUCCESS == mobile_code || + mobile_apis::Result::RETRY == mobile_code; + + if ((mobile_apis::Result::SUCCESS == mobile_code) && + (mobile_apis::Result::UNSUPPORTED_RESOURCE == result_tts_speak_)) { + mobile_code = mobile_apis::Result::WARNINGS; + return_info = "Unsupported phoneme type sent in a prompt"; + } + + SendResponse(result, mobile_code, return_info.c_str(), + &(message[strings::msg_params])); + break; + } + case hmi_apis::FunctionID::TTS_Speak: { + LOG4CXX_INFO(logger_, "Received TTS_Speak event"); + result_tts_speak_ = GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asUInt())); + is_active_tts_speak_ = false; + SendRecordStartNotification(); + StartMicrophoneRecording(); + ApplicationManagerImpl::instance()-> + updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + break; + } + case hmi_apis::FunctionID::TTS_OnResetTimeout: { + LOG4CXX_INFO(logger_, "Received TTS_OnResetTimeout event"); + + ApplicationManagerImpl::instance()->updateRequestTimeout( + connection_key(), correlation_id(), default_timeout()); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +void PerformAudioPassThruRequest::SendSpeakRequest() { + // crate HMI TTS speak request + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if ((*message_)[str::msg_params].keyExists(str::initial_prompt) && + (0 < (*message_)[str::msg_params][str::initial_prompt].length())) { + for (uint32_t i = 0; + i < (*message_)[str::msg_params][str::initial_prompt].length(); + ++i) { + msg_params[hmi_request::tts_chunks][i][str::text] = + (*message_)[str::msg_params][str::initial_prompt][i][str::text]; + msg_params[hmi_request::tts_chunks][i][str::type] = + (*message_)[str::msg_params][str::initial_prompt][i][str::type]; + } + // app_id + msg_params[strings::app_id] = connection_key(); + is_active_tts_speak_ = true; + SendHMIRequest(hmi_apis::FunctionID::TTS_Speak, &msg_params, true); + } +} + +void PerformAudioPassThruRequest::SendPerformAudioPassThruRequest() { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[str::app_id] = connection_key(); + + // duration + msg_params[hmi_request::max_duration] = + (*message_)[str::msg_params][str::max_duration]; + + msg_params[hmi_request::audio_pass_display_texts] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + + if ((*message_)[str::msg_params].keyExists(str::audio_pass_display_text1)) { + msg_params[hmi_request::audio_pass_display_texts] + [0][hmi_request::field_name] = static_cast<int32_t> + (hmi_apis::Common_TextFieldName::audioPassThruDisplayText1); + msg_params[hmi_request::audio_pass_display_texts] + [0][hmi_request::field_text] = + (*message_)[str::msg_params][str::audio_pass_display_text1]; + } + + if ((*message_)[str::msg_params].keyExists(str::audio_pass_display_text2)) { + msg_params[hmi_request::audio_pass_display_texts] + [1][hmi_request::field_name] = static_cast<int32_t> + (hmi_apis::Common_TextFieldName::audioPassThruDisplayText2); + msg_params[hmi_request::audio_pass_display_texts] + [1][hmi_request::field_text] = + (*message_)[str::msg_params][str::audio_pass_display_text2]; + } + + if ((*message_)[str::msg_params].keyExists(str::mute_audio)) { + msg_params[str::mute_audio] = + (*message_)[str::msg_params][str::mute_audio].asBool(); + } else { + // If omitted, the value is set to true + msg_params[str::mute_audio] = true; + } + + SendHMIRequest(hmi_apis::FunctionID::UI_PerformAudioPassThru, + &msg_params, true); +} + +void PerformAudioPassThruRequest::SendRecordStartNotification() { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = connection_key(); + + CreateHMINotification(hmi_apis::FunctionID::UI_OnRecordStart, msg_params); +} + +void PerformAudioPassThruRequest::StartMicrophoneRecording() { + ApplicationManagerImpl::instance()->begin_audio_pass_thru(); + + ApplicationManagerImpl::instance()->StartAudioPassThruThread( + connection_key(), correlation_id(), + (*message_)[str::msg_params][str::max_duration].asInt(), + (*message_)[str::msg_params][str::sampling_rate].asInt(), + (*message_)[str::msg_params][str::bits_per_sample].asInt(), + (*message_)[str::msg_params][str::audio_type].asInt()); +} + +bool PerformAudioPassThruRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "PerformAudioPassThruRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::initial_prompt)) { + const smart_objects::SmartArray* ip_array = + (*message_)[strings::msg_params][strings::initial_prompt].asArray(); + + smart_objects::SmartArray::const_iterator it_ip = ip_array->begin(); + smart_objects::SmartArray::const_iterator it_ip_end = ip_array->end(); + + for (; it_ip != it_ip_end; ++it_ip) { + str = (*it_ip)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid initial_prompt syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params]. + keyExists(strings::audio_pass_display_text1)) { + + str = (*message_)[strings::msg_params] + [strings::audio_pass_display_text1].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid audio_pass_display_text1 value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params]. + keyExists(strings::audio_pass_display_text2)) { + + str = (*message_)[strings::msg_params] + [strings::audio_pass_display_text2].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid audio_pass_display_text2 value syntax check failed"); + return true; + } + } + return false; +} + +void PerformAudioPassThruRequest::FinishTTSSpeak(){ + if (is_active_tts_speak_) { + is_active_tts_speak_ = false; + SendHMIRequest(hmi_apis::FunctionID::TTS_StopSpeaking, NULL); + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_response.cc b/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_response.cc new file mode 100644 index 0000000000..a10eaac9f3 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/perform_audio_pass_thru_response.cc @@ -0,0 +1,58 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/perform_audio_pass_thru_response.h" +#include "application_manager/application_manager_impl.h" + + +namespace application_manager { + +namespace commands { + +PerformAudioPassThruResponse::PerformAudioPassThruResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +PerformAudioPassThruResponse::~PerformAudioPassThruResponse() { +} + +void PerformAudioPassThruResponse::Run() { + LOG4CXX_INFO(logger_, "PerformAudioPassThruResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/perform_interaction_request.cc b/src/components/application_manager/src/commands/mobile/perform_interaction_request.cc new file mode 100644 index 0000000000..12514626a6 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/perform_interaction_request.cc @@ -0,0 +1,870 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include <string> +#include "application_manager/commands/mobile/perform_interaction_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "config_profile/profile.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +PerformInteractionRequest::PerformInteractionRequest( + const MessageSharedPtr& message) +: CommandRequestImpl(message), + timer_("PerformInteractionReq", this, &PerformInteractionRequest::onTimer), + vr_perform_interaction_code_(mobile_apis::Result::INVALID_ENUM), + interaction_mode_(mobile_apis::InteractionMode::INVALID_ENUM), + ui_response_recived(false), + vr_response_recived(false) { + + subscribe_on_event(hmi_apis::FunctionID::UI_OnResetTimeout); + subscribe_on_event(hmi_apis::FunctionID::VR_OnCommand); + subscribe_on_event(hmi_apis::FunctionID::Buttons_OnButtonPress); +} + +PerformInteractionRequest::~PerformInteractionRequest() { +} + +void PerformInteractionRequest::onTimer() { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::onTimer"); +} + +bool PerformInteractionRequest::Init() { + + /* Timeout in milliseconds. + If omitted a standard value of 10000 milliseconds is used.*/ + if ((*message_)[strings::msg_params].keyExists(strings::timeout)) { + default_timeout_ = + (*message_)[strings::msg_params][strings::timeout].asUInt(); + } + mobile_apis::InteractionMode::eType mode = + static_cast<mobile_apis::InteractionMode::eType>( + (*message_)[strings::msg_params][strings::interaction_mode].asInt()); + + if (mobile_apis::InteractionMode::BOTH == mode || + mobile_apis::InteractionMode::MANUAL_ONLY == mode) { + default_timeout_ *= 2; + } + return true; +} + +void PerformInteractionRequest::Run() { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::Run"); + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + mobile_apis::LayoutMode::eType interaction_layout = + mobile_apis::LayoutMode::INVALID_ENUM; + if ((*message_)[strings::msg_params].keyExists( + hmi_request::interaction_layout)) { + interaction_layout = static_cast<mobile_apis::LayoutMode::eType>( + (*message_)[strings::msg_params][hmi_request::interaction_layout].asInt()); + } + + if ((mobile_apis::InteractionMode::VR_ONLY == + static_cast<mobile_apis::InteractionMode::eType>( + (*message_)[strings::msg_params][strings::interaction_mode].asInt())) && + (mobile_apis::LayoutMode::KEYBOARD == interaction_layout)) { + LOG4CXX_ERROR_EXT( + logger_, + "PerformInteraction contains InteractionMode = VR_ONLY and " + "interactionLayout=KEYBOARD"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if ((0 == (*message_) + [strings::msg_params][strings::interaction_choice_set_id_list].length()) && + (mobile_apis::InteractionMode::BOTH == + static_cast<mobile_apis::InteractionMode::eType>( + (*message_)[strings::msg_params][strings::interaction_mode].asInt()))) { + LOG4CXX_ERROR_EXT( + logger_, + "interactionChoiceSetIDList is empty and InteractionMode=BOTH"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if ((0 == (*message_) + [strings::msg_params][strings::interaction_choice_set_id_list].length()) && + (mobile_apis::LayoutMode::KEYBOARD != interaction_layout)) { + LOG4CXX_ERROR_EXT( + logger_, + "interactionChoiceSetIDList is empty and without parameter" + "interactionLayout=KEYBOARD"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if ((*message_)[strings::msg_params].keyExists(strings::vr_help)) { + if (mobile_apis::Result::SUCCESS != MessageHelper::VerifyImageVrHelpItems( + (*message_)[strings::msg_params][strings::vr_help], app)) { + LOG4CXX_ERROR_EXT( + logger_, + "MessageHelper::VerifyImageVrHelpItems return INVALID_DATA!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + } + + smart_objects::SmartObject& choice_list = + (*message_)[strings::msg_params][strings::interaction_choice_set_id_list]; + + for (size_t i = 0; i < choice_list.length(); ++i) { + if (!app->FindChoiceSet(choice_list[i].asInt())) { + LOG4CXX_ERROR(logger_, "Invalid ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return; + } + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming perform interaction has contains \t\n \\t \\n"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + int32_t mode = + (*message_)[strings::msg_params][strings::interaction_mode].asInt(); + + app->set_perform_interaction_mode(mode); + + interaction_mode_ = static_cast<mobile_apis::InteractionMode::eType>(mode); + + switch (interaction_mode_) { + case mobile_apis::InteractionMode::BOTH: { + LOG4CXX_INFO(logger_, "Interaction Mode: BOTH"); + if (!CheckChoiceSetVRSynonyms(app)) { + return; + } + + if (!CheckChoiceSetMenuNames(app)) { + return; + } + + if (!CheckVrHelpItemPositions(app)) { + return; + } + + app->set_perform_interaction_active(correlation_id()); + SendVRPerformInteractionRequest(app); + SendUIPerformInteractionRequest(app); + break; + } + case mobile_apis::InteractionMode::MANUAL_ONLY: { + LOG4CXX_INFO(logger_, "Interaction Mode: MANUAL_ONLY"); + + if (!CheckChoiceSetVRSynonyms(app)) { + return; + } + + if (!CheckChoiceSetMenuNames(app)) { + return; + } + + if (!CheckVrHelpItemPositions(app)) { + return; + } + + app->set_perform_interaction_active(correlation_id()); + SendVRPerformInteractionRequest(app); + SendUIPerformInteractionRequest(app); + break; + } + case mobile_apis::InteractionMode::VR_ONLY: { + LOG4CXX_INFO(logger_, "Interaction Mode: VR_ONLY"); + if (!CheckChoiceSetVRSynonyms(app)) { + return; + } + + if (!CheckVrHelpItemPositions(app)) { + return; + } + + // TODO(DK): need to implement timeout + app->set_perform_interaction_active(correlation_id()); + SendVRPerformInteractionRequest(app); + SendUIPerformInteractionRequest(app); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Unknown interaction mode"); + return; + } + } + + // TODO(DK): need to implement timeout TTS speak request. +} + +void PerformInteractionRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::on_event"); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_OnResetTimeout: { + LOG4CXX_INFO(logger_, "Received UI_OnResetTimeout event"); + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + break; + } + case hmi_apis::FunctionID::UI_PerformInteraction: { + LOG4CXX_INFO(logger_, "Received UI_PerformInteraction event"); + ProcessPerformInteractionResponse(event.smart_object()); + break; + } + case hmi_apis::FunctionID::VR_PerformInteraction: { + LOG4CXX_INFO(logger_, "Received TTS_PerformInteraction"); + ProcessVRResponse(event.smart_object()); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + break; + } + } +} + +void PerformInteractionRequest::onTimeOut() { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::onTimeOut"); + + switch (interaction_mode_) { + case mobile_apis::InteractionMode::BOTH: { + if (true == vr_response_recived) { + unsubscribe_from_event(hmi_apis::FunctionID::UI_PerformInteraction); + DisablePerformInteraction(); + CommandRequestImpl::onTimeOut(); + } else { + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + } + break; + } + case mobile_apis::InteractionMode::VR_ONLY: { + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + break; + } + case mobile_apis::InteractionMode::MANUAL_ONLY: { + unsubscribe_from_event(hmi_apis::FunctionID::UI_PerformInteraction); + DisablePerformInteraction(); + CommandRequestImpl::onTimeOut(); + break; + } + default: { + LOG4CXX_ERROR(logger_, "INVALID ENUM"); + return; + } + }; +} + + +void PerformInteractionRequest::ProcessVRResponse( + const smart_objects::SmartObject& message) { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::ProcessVRResponse"); + const uint32_t app_id = connection_key(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + if (!app.get()) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + vr_response_recived = true; + vr_perform_interaction_code_ = static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + if (mobile_apis::Result::ABORTED == vr_perform_interaction_code_ || + mobile_apis::Result::TIMED_OUT == vr_perform_interaction_code_) { + LOG4CXX_INFO(logger_, "VR response aborted"); + if (mobile_apis::InteractionMode::VR_ONLY == interaction_mode_) { + LOG4CXX_INFO(logger_, "Aborted or Timeout Send Close Popup"); + TerminatePerformInteraction(); + SendResponse(false, vr_perform_interaction_code_); + return; + } else { + LOG4CXX_INFO(logger_, "Update timeout for UI"); + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + return; + } + } + + smart_objects::SmartObject msg_params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + smart_objects::SmartObject* ptr_msg_params = NULL; + if (message[strings::msg_params].keyExists(strings::choice_id)) { + if (CheckChoiceIDFromResponse( + app, message[strings::msg_params][strings::choice_id].asInt())) { + msg_params[strings::choice_id] = + message[strings::msg_params][strings::choice_id].asInt(); + ptr_msg_params = &msg_params; + } else { + LOG4CXX_ERROR(logger_, "Wrong choiceID was received from HMI"); + TerminatePerformInteraction(); + SendResponse(false, mobile_apis::Result::GENERIC_ERROR, + "Wrong choiceID was received from HMI"); + return; + } + } + mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM; + + if (mobile_apis::Result::UNSUPPORTED_RESOURCE == + vr_perform_interaction_code_) { + LOG4CXX_INFO(logger_, "VR response WARNINGS"); + result_code = mobile_apis::Result::WARNINGS; + } else { + LOG4CXX_INFO(logger_, "VR response SUCCESS"); + result_code = mobile_apis::Result::SUCCESS; + msg_params[strings::trigger_source] = + static_cast<int32_t>(mobile_apis::TriggerSource::TS_VR); + ptr_msg_params = &msg_params; + } + TerminatePerformInteraction(); + SendResponse(true, result_code, NULL, ptr_msg_params); +} + +void PerformInteractionRequest::ProcessPerformInteractionResponse( + const smart_objects::SmartObject& message) { + LOG4CXX_INFO(logger_, + "PerformInteractionRequest::ProcessPerformInteractionResponse"); + const uint32_t app_id = connection_key(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + if (!app.get()) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + ui_response_recived = true; + + smart_objects::SmartObject msg_params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + msg_params = message[strings::msg_params]; + bool result = false; + + mobile_apis::Result::eType result_code = + GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asUInt())); + + if ((mobile_apis::Result::SUCCESS == result_code) || + (mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code)) { + if (message[strings::msg_params].keyExists(strings::choice_id) && + !(CheckChoiceIDFromResponse( + app, message[strings::msg_params][strings::choice_id].asInt()))) { + DisablePerformInteraction(); + SendResponse(false, mobile_apis::Result::GENERIC_ERROR, + "Wrong choiceID was received from HMI"); + return; + } + if (message[strings::msg_params].keyExists(strings::manual_text_entry)) { + msg_params[strings::trigger_source] = mobile_apis::TriggerSource::TS_KEYBOARD; + } else { + msg_params[strings::trigger_source] = mobile_apis::TriggerSource::TS_MENU; + } + DisablePerformInteraction(); + result = true; + } else if (mobile_apis::Result::REJECTED == result_code) { + LOG4CXX_ERROR(logger_, "Request was rejected"); + } + + const char* return_info = NULL; + if (result) { + if (mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code) { + result_code = mobile_apis::Result::WARNINGS; + return_info = + std::string("Unsupported phoneme type sent in any item").c_str(); + } + } + + if (mobile_apis::Result::TIMED_OUT == result_code) { + DisablePerformInteraction(); + } + + SendResponse(result, result_code, return_info, &(msg_params)); +} + +void PerformInteractionRequest::SendUIPerformInteractionRequest( + application_manager::ApplicationSharedPtr const app) { + smart_objects::SmartObject& choice_set_id_list = + (*message_)[strings::msg_params][strings::interaction_choice_set_id_list]; + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + mobile_apis::InteractionMode::eType mode = + static_cast<mobile_apis::InteractionMode::eType>( + (*message_)[strings::msg_params][strings::interaction_mode].asInt()); + + if (mobile_apis::InteractionMode::VR_ONLY != mode) { + msg_params[hmi_request::initial_text][hmi_request::field_name] = + static_cast<int32_t>( + hmi_apis::Common_TextFieldName::initialInteractionText); + msg_params[hmi_request::initial_text][hmi_request::field_text] = + (*message_)[strings::msg_params][hmi_request::initial_text]; + } + bool is_vr_help_item = false; + if (mobile_apis::InteractionMode::MANUAL_ONLY != mode) { + msg_params[strings::vr_help_title] = + (*message_)[strings::msg_params][strings::initial_text].asString(); + if ((*message_)[strings::msg_params].keyExists(strings::vr_help)) { + is_vr_help_item = true; + msg_params[strings::vr_help] = + (*message_)[strings::msg_params][strings::vr_help]; + } + } + + if (mobile_apis::InteractionMode::BOTH == mode || + mobile_apis::InteractionMode::MANUAL_ONLY == mode) { + msg_params[strings::timeout] = default_timeout_/2; + } else { + msg_params[strings::timeout] = default_timeout_; + } + msg_params[strings::app_id] = app->app_id(); + if (mobile_apis::InteractionMode::VR_ONLY != mode) { + msg_params[strings::choice_set] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + } + int32_t index_array_of_vr_help = 0; + for (size_t i = 0; i < choice_set_id_list.length(); ++i) { + smart_objects::SmartObject* choice_set = app->FindChoiceSet( + choice_set_id_list[i].asInt()); + if (choice_set) { + // save perform interaction choice set + app->AddPerformInteractionChoiceSet(choice_set_id_list[i].asInt(), + *choice_set); + for (size_t j = 0; j < (*choice_set)[strings::choice_set].length(); ++j) { + if (mobile_apis::InteractionMode::VR_ONLY != mode) { + size_t index = msg_params[strings::choice_set].length(); + msg_params[strings::choice_set][index] = + (*choice_set)[strings::choice_set][j]; + // vrCommands should be added via VR.AddCommand only + msg_params[strings::choice_set][index].erase(strings::vr_commands); + } + if (mobile_apis::InteractionMode::MANUAL_ONLY != + mode && !is_vr_help_item) { + smart_objects::SmartObject& vr_commands = + (*choice_set)[strings::choice_set][j][strings::vr_commands]; + if (0 < vr_commands.length()) { + // copy only first synonym + smart_objects::SmartObject item(smart_objects::SmartType_Map); + item[strings::text] = vr_commands[0].asString(); + item[strings::position] = index_array_of_vr_help + 1; + msg_params[strings::vr_help][index_array_of_vr_help++] = item; + } + } + } + } + } + if ((*message_)[strings::msg_params] + .keyExists(hmi_request::interaction_layout) + && mobile_apis::InteractionMode::VR_ONLY != mode) { + msg_params[hmi_request::interaction_layout] = + (*message_)[strings::msg_params][hmi_request::interaction_layout]. + asInt(); + } + CreateUIPerformInteraction(msg_params, app); +} + +void PerformInteractionRequest::CreateUIPerformInteraction( + const smart_objects::SmartObject& msg_params, + application_manager::ApplicationSharedPtr const app) { + SendHMIRequest(hmi_apis::FunctionID::UI_PerformInteraction, + &msg_params, true); +} + +void PerformInteractionRequest::SendVRPerformInteractionRequest( + application_manager::ApplicationSharedPtr const app) { + smart_objects::SmartObject msg_params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + smart_objects::SmartObject& choice_list = + (*message_)[strings::msg_params][strings::interaction_choice_set_id_list]; + + if (mobile_apis::InteractionMode::MANUAL_ONLY != interaction_mode_) { + msg_params[strings::grammar_id] = smart_objects::SmartObject(smart_objects::SmartType_Array); + int32_t grammar_id_index = 0; + for (uint32_t i = 0; i < choice_list.length(); ++i) { + smart_objects::SmartObject* choice_set = + app->FindChoiceSet(choice_list[i].asInt()); + if (!choice_set) { + LOG4CXX_WARN(logger_, "Couldn't found choiset"); + continue; + } + msg_params[strings::grammar_id][grammar_id_index++]= + (*choice_set)[strings::grammar_id].asUInt(); + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::help_prompt)) { + + msg_params[strings::help_prompt] = + (*message_)[strings::msg_params][strings::help_prompt]; + + } else { + if (choice_list.length() != 0) { + msg_params[strings::help_prompt] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + } + int32_t index = 0; + for (uint32_t i = 0; i < choice_list.length(); ++i) { + smart_objects::SmartObject* choice_set = + app->FindChoiceSet(choice_list[i].asInt()); + + if (choice_set) { + for (uint32_t j = 0; + j < (*choice_set)[strings::choice_set].length(); + ++j) { + smart_objects::SmartObject& vr_commands = + (*choice_set)[strings::choice_set][j][strings::vr_commands]; + if (0 < vr_commands.length()) { + // copy only first synonym + smart_objects::SmartObject item(smart_objects::SmartType_Map); + // Since there is no custom data from application side, SDL should + // construct prompt and append delimiter to each item + item[strings::text] = vr_commands[0].asString() + + profile::Profile::instance()->tts_delimiter(); + msg_params[strings::help_prompt][index++] = item; + } + } + } else { + LOG4CXX_ERROR(logger_, "Can't found choiceSet!"); + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::timeout_prompt)) { + msg_params[strings::timeout_prompt] = + (*message_)[strings::msg_params][strings::timeout_prompt]; + } else { + if (msg_params.keyExists(strings::help_prompt)) { + msg_params[strings::timeout_prompt] = msg_params[strings::help_prompt]; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::initial_prompt)) { + msg_params[strings::initial_prompt] = + (*message_)[strings::msg_params][strings::initial_prompt]; + } + + mobile_apis::InteractionMode::eType mode = + static_cast<mobile_apis::InteractionMode::eType>( + (*message_)[strings::msg_params][strings::interaction_mode].asInt()); + + if (mobile_apis::InteractionMode::BOTH == mode || + mobile_apis::InteractionMode::MANUAL_ONLY == mode) { + msg_params[strings::timeout] = default_timeout_/2; + } else { + msg_params[strings::timeout] = default_timeout_; + } + + SendHMIRequest(hmi_apis::FunctionID::VR_PerformInteraction, &msg_params, + true); +} + +bool PerformInteractionRequest::CheckChoiceSetMenuNames( + application_manager::ApplicationSharedPtr const app) { + smart_objects::SmartObject& choice_list = + (*message_)[strings::msg_params][strings::interaction_choice_set_id_list]; + + for (size_t i = 0; i < choice_list.length(); ++i) { + // choice_set contains SmartObject msg_params + smart_objects::SmartObject* i_choice_set = app->FindChoiceSet( + choice_list[i].asInt()); + + for (size_t j = 0; j < choice_list.length(); ++j) { + smart_objects::SmartObject* j_choice_set = app->FindChoiceSet( + choice_list[j].asInt()); + + if (i == j) { + // skip check the same element + continue; + } + + if (!i_choice_set || !j_choice_set) { + LOG4CXX_ERROR(logger_, "Invalid ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return false; + } + + size_t ii = 0; + size_t jj = 0; + for (; ii < (*i_choice_set)[strings::choice_set].length(); ++ii) { + for (; jj < (*j_choice_set)[strings::choice_set].length(); ++jj) { + std::string ii_menu_name = + (*i_choice_set)[strings::choice_set][ii][strings::menu_name] + .asString(); + std::string jj_menu_name = + (*j_choice_set)[strings::choice_set][jj][strings::menu_name] + .asString(); + + if (ii_menu_name == jj_menu_name) { + LOG4CXX_ERROR(logger_, "Choice set has duplicated menu name"); + SendResponse(false, mobile_apis::Result::DUPLICATE_NAME, + "Choice set has duplicated menu name"); + return false; + } + } + } + } + } + + return true; +} + +bool PerformInteractionRequest::CheckChoiceSetVRSynonyms( + application_manager::ApplicationSharedPtr const app) { + smart_objects::SmartObject& choice_list = + (*message_)[strings::msg_params][strings::interaction_choice_set_id_list]; + + for (size_t i = 0; i < choice_list.length(); ++i) { + // choice_set contains SmartObject msg_params + smart_objects::SmartObject* i_choice_set = app->FindChoiceSet( + choice_list[i].asInt()); + + for (size_t j = 0; j < choice_list.length(); ++j) { + smart_objects::SmartObject* j_choice_set = app->FindChoiceSet( + choice_list[j].asInt()); + + if (i == j) { + // skip check the same element + continue; + } + + if ((!i_choice_set) || (!j_choice_set)) { + LOG4CXX_ERROR(logger_, "Invalid ID"); + SendResponse(false, mobile_apis::Result::INVALID_ID); + return false; + } + + size_t ii = 0; + size_t jj = 0; + for (; ii < (*i_choice_set)[strings::choice_set].length(); ++ii) { + for (; jj < (*j_choice_set)[strings::choice_set].length(); ++jj) { + // choice_set pointer contains SmartObject msg_params + smart_objects::SmartObject& ii_vr_commands = + (*i_choice_set)[strings::choice_set][ii][strings::vr_commands]; + + smart_objects::SmartObject& jj_vr_commands = + (*j_choice_set)[strings::choice_set][jj][strings::vr_commands]; + + for (size_t iii = 0; iii < ii_vr_commands.length(); ++iii) { + for (size_t jjj = 0; jjj < jj_vr_commands.length(); ++jjj) { + std::string vr_cmd_i = ii_vr_commands[iii].asString(); + std::string vr_cmd_j = jj_vr_commands[jjj].asString(); + if (0 == strcasecmp(vr_cmd_i.c_str(), vr_cmd_j.c_str())) { + LOG4CXX_ERROR(logger_, "Choice set has duplicated VR synonym"); + SendResponse(false, mobile_apis::Result::DUPLICATE_NAME, + "Choice set has duplicated VR synonym"); + return false; + } + } + } + } + } + } + } + + return true; +} + +bool PerformInteractionRequest::CheckVrHelpItemPositions( + application_manager::ApplicationSharedPtr const app) { + + if (!(*message_)[strings::msg_params].keyExists(strings::vr_help)) { + LOG4CXX_INFO(logger_, "" + "PerformInteractionRequest::CheckVrHelpItemPositions vr_help omitted"); + return true; + } + + smart_objects::SmartObject& vr_help = + (*message_)[strings::msg_params][strings::vr_help]; + + int32_t position = 1; + for (size_t i = 0; i < vr_help.length(); ++i) { + if (position != vr_help[i][strings::position].asInt()) { + LOG4CXX_ERROR(logger_, "Non-sequential vrHelp item position"); + SendResponse(false, mobile_apis::Result::REJECTED, + "Non-sequential vrHelp item position"); + return false; + } + ++position; + } + return true; +} + +void PerformInteractionRequest::DisablePerformInteraction() { + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + if (app->is_perform_interaction_active()) { + app->set_perform_interaction_active(0); + app->set_perform_interaction_mode(-1); + app->DeletePerformInteractionChoiceSetMap(); + } +} + +bool PerformInteractionRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + str = (*message_)[strings::msg_params][strings::initial_text].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid initial_text syntax check failed"); + return true; + } + + + if ((*message_)[strings::msg_params].keyExists(strings::initial_prompt)) { + const smart_objects::SmartArray* ip_array = + (*message_)[strings::msg_params][strings::initial_prompt].asArray(); + + smart_objects::SmartArray::const_iterator it_ip = ip_array->begin(); + smart_objects::SmartArray::const_iterator it_ip_end = ip_array->end(); + + for (; it_ip != it_ip_end; ++it_ip) { + str = (*it_ip)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid initial_prompt syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::help_prompt)) { + const smart_objects::SmartArray* hp_array = + (*message_)[strings::msg_params][strings::help_prompt].asArray(); + + smart_objects::SmartArray::const_iterator it_hp = hp_array->begin(); + smart_objects::SmartArray::const_iterator it_hp_end = hp_array->end(); + + for (; it_hp != it_hp_end; ++it_hp) { + str = (*it_hp)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid help_prompt syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::timeout_prompt)) { + const smart_objects::SmartArray* tp_array = + (*message_)[strings::msg_params][strings::timeout_prompt].asArray(); + + smart_objects::SmartArray::const_iterator it_tp = tp_array->begin(); + smart_objects::SmartArray::const_iterator it_tp_end = tp_array->end(); + + for (; it_tp != it_tp_end; ++it_tp) { + str = (*it_tp)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid timeout_prompt syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::vr_help)) { + const smart_objects::SmartArray* vh_array = + (*message_)[strings::msg_params][strings::vr_help].asArray(); + + smart_objects::SmartArray::const_iterator it_vh = vh_array->begin(); + smart_objects::SmartArray::const_iterator it_vh_end = vh_array->end(); + + for (; it_vh != it_vh_end; ++it_vh) { + str = (*it_vh)[strings::text].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_help syntax check failed"); + return true; + } + + if ((*it_vh).keyExists(strings::image)) { + str = (*it_vh)[strings::image][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid vr_help image value syntax check failed"); + return true; + } + } + } + } + return false; +} + +void PerformInteractionRequest::TerminatePerformInteraction() { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[hmi_request::method_name] = "UI.PerformInteraction"; + SendHMIRequest(hmi_apis::FunctionID::UI_ClosePopUp, &msg_params); + DisablePerformInteraction(); +} + +bool PerformInteractionRequest::CheckChoiceIDFromResponse( + ApplicationSharedPtr app, int32_t choice_id) { + LOG4CXX_INFO(logger_, "PerformInteractionRequest::CheckChoiceIDFromResponse"); + const PerformChoiceSetMap& choice_set_map = app + ->performinteraction_choice_set_map(); + + for (PerformChoiceSetMap::const_iterator it = choice_set_map.begin(); + choice_set_map.end() != it; ++it) { + const smart_objects::SmartObject& choice_set = (*it->second).getElement( + strings::choice_set); + for (size_t j = 0; j < choice_set.length(); ++j) { + if (choice_id == + choice_set.getElement(j).getElement(strings::choice_id).asInt()) { + return true; + } + } + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/perform_interaction_response.cc b/src/components/application_manager/src/commands/mobile/perform_interaction_response.cc new file mode 100644 index 0000000000..4ceb4ce3b3 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/perform_interaction_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/perform_interaction_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +PerformInteractionResponse::PerformInteractionResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +PerformInteractionResponse::~PerformInteractionResponse() { +} + +void PerformInteractionResponse::Run() { + LOG4CXX_INFO(logger_, "PerformInteractionResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/put_file_request.cc b/src/components/application_manager/src/commands/mobile/put_file_request.cc new file mode 100644 index 0000000000..8bb83888d6 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/put_file_request.cc @@ -0,0 +1,250 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/put_file_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/application_impl.h" +#include "config_profile/profile.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +PutFileRequest::PutFileRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) + , offset_(0) + , sync_file_name_() + , length_(0) + , file_type_(mobile_apis::FileType::INVALID_ENUM) + , is_persistent_file_(false) { +} + +PutFileRequest::~PutFileRequest() { +} + +void PutFileRequest::Run() { + LOG4CXX_INFO(logger_, "PutFileRequest::Run"); + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + smart_objects::SmartObject response_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!application) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (mobile_api::HMILevel::HMI_NONE == application->hmi_level() && + profile::Profile::instance()->put_file_in_none() <= + application->put_file_in_none_count()) { + // If application is in the HMI_NONE level the quantity of allowed + // PutFile request is limited by the configuration profile + LOG4CXX_ERROR(logger_, + "Too many requests from the app with HMILevel HMI_NONE "); + SendResponse(false, mobile_apis::Result::REJECTED, + "Too many requests from the app with HMILevel HMI_NONE", + &response_params); + return; + } + + if (!(*message_)[strings::params].keyExists(strings::binary_data)) { + LOG4CXX_ERROR(logger_, "Binary data empty"); + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "Binary data empty", + &response_params); + return; + } + + if (!(*message_)[strings::msg_params].keyExists(strings::sync_file_name)) { + LOG4CXX_ERROR(logger_, "No file name"); + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "No file name", + &response_params); + return; + } + + if (!(*message_)[strings::msg_params].keyExists(strings::file_type)) { + LOG4CXX_ERROR(logger_, "No file type"); + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "No file type", + &response_params); + return; + } + sync_file_name_ = + (*message_)[strings::msg_params][strings::sync_file_name].asString(); + file_type_ = + static_cast<mobile_apis::FileType::eType>( + (*message_)[strings::msg_params][strings::file_type].asInt()); + const std::vector<uint8_t> binary_data = + (*message_)[strings::params][strings::binary_data].asBinary(); + + // Policy table update in json format is currently to be received via PutFile + // TODO(PV): after latest discussion has to be changed + if (mobile_apis::FileType::JSON == file_type_) { + policy::PolicyHandler::instance()->ReceiveMessageFromSDK(sync_file_name_, binary_data); + } + + offset_ = 0; + is_persistent_file_ = false; + bool is_system_file = false; + length_ = binary_data.size(); + bool is_download_compleate = true; + bool offset_exist = + (*message_)[strings::msg_params].keyExists(strings::offset); + + if (offset_exist) { + offset_ = (*message_)[strings::msg_params][strings::offset].asInt64(); + } + + if ((*message_)[strings::msg_params]. + keyExists(strings::persistent_file)) { + is_persistent_file_ = + (*message_)[strings::msg_params][strings::persistent_file].asBool(); + } + if ((*message_)[strings::msg_params]. + keyExists(strings::system_file)) { + is_system_file = + (*message_)[strings::msg_params][strings::system_file].asBool(); + } + + std::string file_path; + + if (is_system_file) { + response_params[strings::space_available] = 0; + file_path = profile::Profile::instance()->system_files_path(); + } else { + file_path = profile::Profile::instance()->app_storage_folder(); + file_path += "/" + application->folder_name(); + + if (binary_data.size() > + ApplicationManagerImpl::instance()->GetAvailableSpaceForApp(application->name())) { + LOG4CXX_ERROR(logger_, "Out of memory"); + SendResponse(false, mobile_apis::Result::OUT_OF_MEMORY, + "Out of memory", &response_params); + return; + } + } + + if (!file_system::CreateDirectoryRecursively(file_path)) { + LOG4CXX_ERROR(logger_, "Cann't create folder"); + SendResponse(false, mobile_apis::Result::GENERIC_ERROR, + "Cann't create folder.", &response_params); + return; + } + + mobile_apis::Result::eType save_result = + ApplicationManagerImpl::instance()->SaveBinary(binary_data, file_path, + sync_file_name_, offset_); + if (!is_system_file) { + response_params[strings::space_available] = static_cast<int32_t>( + ApplicationManagerImpl::instance()->GetAvailableSpaceForApp(application->folder_name())); + } + + sync_file_name_ = file_path + "/" + sync_file_name_; + switch (save_result) { + case mobile_apis::Result::SUCCESS: { + + if (!is_system_file) { + AppFile file(sync_file_name_, is_persistent_file_, + is_download_compleate, file_type_); + + if (0 == offset_) { + LOG4CXX_INFO(logger_, "New file downloading"); + if (!application->AddFile(file)) { + + LOG4CXX_INFO(logger_, + "Couldn't add file to application (File already Exist" + << " in application and was rewritten on FS)"); + /* It can be first part of new big file, so we need to update + information about it's downloading status and persistence */ + if (!application->UpdateFile(file)) { + LOG4CXX_INFO(logger_, "Couldn't update file"); + /* If it is impossible to update file, application doesn't + know about existing this file */ + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "Couldn't update file", + &response_params); + return; + } + } else { + /* if file added - increment it's count + ( may be application->AddFile have to incapsulate it? ) + Any way now this method evals not only in "none"*/ + application->increment_put_file_in_none_count(); + } + } + } + + SendResponse(true, save_result, "File was downloaded", &response_params); + if (is_system_file) { + SendOnPutFileNotification(); + } + break; + } + default: + LOG4CXX_INFO(logger_, "Save in unsuccessful. Result = " << save_result); + SendResponse(false, save_result, "Can't save file", &response_params); + break; + } +} + +void PutFileRequest::SendOnPutFileNotification() { + LOG4CXX_INFO(logger_, "SendOnPutFileNotification" ); + smart_objects::SmartObject* notification = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& message = *notification; + message[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_OnPutFile; + + message[strings::params][strings::message_type] = MessageType::kNotification; + message[strings::msg_params][strings::app_id] = connection_key(); + message[strings::msg_params][strings::sync_file_name] = sync_file_name_; + message[strings::msg_params][strings::offset] = offset_; + if (0 == offset_) { + message[strings::msg_params][strings::file_size] = + (*message_)[strings::msg_params][strings::length]; + } + message[strings::msg_params][strings::length] = length_; + message[strings::msg_params][strings::persistent_file] = is_persistent_file_; + message[strings::msg_params][strings::file_type] = file_type_; + ApplicationManagerImpl::instance()->ManageHMICommand(&message); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/put_file_response.cc b/src/components/application_manager/src/commands/mobile/put_file_response.cc new file mode 100644 index 0000000000..4ab950d7a8 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/put_file_response.cc @@ -0,0 +1,67 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/put_file_response.h" +#include "utils/file_system.h" +#include "application_manager/application_impl.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +PutFileResponse::PutFileResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +PutFileResponse::~PutFileResponse() { +} + +void PutFileResponse::Run() { + LOG4CXX_INFO(logger_, "PutFileResponse::Run"); + uint32_t app_id = (*message_)[strings::params][strings::connection_key] + .asUInt(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + if (!app) { + LOG4CXX_ERROR(logger_, "Application not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + + SendResponse((*message_)[strings::msg_params][strings::success].asBool()); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/read_did_request.cc b/src/components/application_manager/src/commands/mobile/read_did_request.cc new file mode 100644 index 0000000000..1de080df4c --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/read_did_request.cc @@ -0,0 +1,122 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/read_did_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ReadDIDRequest::ReadDIDRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +ReadDIDRequest::~ReadDIDRequest() { +} + +void ReadDIDRequest::Run() { + LOG4CXX_INFO(logger_, "ReadDIDRequest::Run"); + + uint32_t app_id = (*message_)[strings::params][strings::connection_key] + .asUInt(); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + LOG4CXX_INFO(logger_, "Correlation_id :" << (*message_)[strings::params][strings::correlation_id] + .asUInt()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "An application is not registered."); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (mobile_api::HMILevel::HMI_NONE == app->hmi_level()) { + SendResponse(false, mobile_apis::Result::REJECTED); + LOG4CXX_ERROR(logger_, "Rejected"); + return; + } + + if (app->IsCommandLimitsExceeded( + static_cast<mobile_apis::FunctionID::eType>(function_id()), + application_manager::TLimitSource::CONFIG_FILE)) { + LOG4CXX_ERROR(logger_, "ReadDID frequency is too high."); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + if ((*message_)[strings::msg_params][strings::did_location].empty()) { + LOG4CXX_ERROR_EXT(logger_, "INVALID_DATA"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::ecu_name] = + (*message_)[strings::msg_params][strings::ecu_name]; + msg_params[strings::did_location] = + (*message_)[strings::msg_params][strings::did_location]; + + SendHMIRequest(hmi_apis::FunctionID::VehicleInfo_ReadDID, &msg_params, true); +} + +void ReadDIDRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ReadDIDRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::VehicleInfo_ReadDID: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/read_did_response.cc b/src/components/application_manager/src/commands/mobile/read_did_response.cc new file mode 100644 index 0000000000..888b590758 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/read_did_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/read_did_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +ReadDIDResponse::ReadDIDResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +ReadDIDResponse::~ReadDIDResponse() { +} + +void ReadDIDResponse::Run() { + LOG4CXX_INFO(logger_, "ReadDIDResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc new file mode 100644 index 0000000000..d33a99a0a9 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc @@ -0,0 +1,881 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/register_app_interface_request.h" + +#include <unistd.h> +#include <algorithm> +#include <string.h> + +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "application_manager/policies/policy_handler.h" +#include "config_profile/profile.h" +#include "interfaces/MOBILE_API.h" + +namespace { + +mobile_apis::AppHMIType::eType StringToAppHMIType(const std::string& str) { + if ("DEFAULT" == str) { + return mobile_apis::AppHMIType::DEFAULT; + } else if ("COMMUNICATION" == str) { + return mobile_apis::AppHMIType::COMMUNICATION; + } else if ("MEDIA" == str) { + return mobile_apis::AppHMIType::MEDIA; + } else if ("MESSAGING" == str) { + return mobile_apis::AppHMIType::MESSAGING; + } else if ("NAVIGATION" == str) { + return mobile_apis::AppHMIType::NAVIGATION; + } else if ("INFORMATION" == str) { + return mobile_apis::AppHMIType::INFORMATION; + } else if ("SOCIAL" == str) { + return mobile_apis::AppHMIType::SOCIAL; + } else if ("BACKGROUND_PROCESS" == str) { + return mobile_apis::AppHMIType::BACKGROUND_PROCESS; + } else if ("TESTING" == str) { + return mobile_apis::AppHMIType::TESTING; + } else if ("SYSTEM" == str) { + return mobile_apis::AppHMIType::SYSTEM; + } else { + return mobile_apis::AppHMIType::INVALID_ENUM; + } +} + +struct AppHMITypeInserter { + AppHMITypeInserter(smart_objects::SmartObject& so_array) + : index_(0), + so_array_(so_array) { + } + + bool operator()(const std::string& app_hmi_type) { + so_array_[index_] = StringToAppHMIType(app_hmi_type); + ++index_; + return true; + } + + private: + uint32_t index_; + smart_objects::SmartObject& so_array_; +}; + +struct CheckMissedTypes { + CheckMissedTypes(const policy::StringArray& policy_app_types, + std::string& log) + : policy_app_types_(policy_app_types), + log_(log) { + } + + bool operator()(const smart_objects::SmartArray::value_type& value) { + std::string app_type_str = value.asString(); + policy::StringArray::const_iterator it = policy_app_types_.begin(); + policy::StringArray::const_iterator it_end = policy_app_types_.end(); + for (; it != it_end; ++it) { + if (app_type_str == *it) { + return true; + } + } + + log_ += app_type_str; + log_ += ","; + + return true; + } + + private: + const policy::StringArray& policy_app_types_; + std::string& log_; +}; +} + +namespace application_manager { + +namespace commands { + +RegisterAppInterfaceRequest::RegisterAppInterfaceRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +RegisterAppInterfaceRequest::~RegisterAppInterfaceRequest() { +} + +bool RegisterAppInterfaceRequest::Init() { + LOG4CXX_INFO(logger_, "RegisterAppInterfaceRequest::Init"); + return true; +} + +void RegisterAppInterfaceRequest::Run() { + LOG4CXX_INFO(logger_, "RegisterAppInterfaceRequest::Run " << connection_key()); + + // Fix problem with SDL and HMI HTML. This problem is not actual for HMI PASA. + // Flag conditional compilation "CUSTOMER_PASA" is used in order to exclude hit code + // to RTC + if (true == profile::Profile::instance()->launch_hmi()) { + // wait till HMI started + while (!ApplicationManagerImpl::instance()->IsHMICooperating()) { + sleep(1); + // TODO(DK): timer_->StartWait(1); + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + } + } + + std::string mobile_app_id = (*message_)[strings::msg_params][strings::app_id] + .asString(); + if (policy::PolicyHandler::instance()->IsApplicationRevoked(mobile_app_id)) { + SendResponse(false, mobile_apis::Result::DISALLOWED); + return; + } + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (application) { + SendResponse(false, mobile_apis::Result::APPLICATION_REGISTERED_ALREADY); + return; + } + + mobile_apis::Result::eType policy_result = CheckWithPolicyData(); + if (mobile_apis::Result::SUCCESS != policy_result + && mobile_apis::Result::WARNINGS != policy_result) { + SendResponse(false, policy_result); + return; + } + + mobile_apis::Result::eType coincidence_result = CheckCoincidence(); + + if (mobile_apis::Result::SUCCESS != coincidence_result) { + LOG4CXX_ERROR_EXT(logger_, "Coincidence check failed."); + if (mobile_apis::Result::DUPLICATE_NAME == coincidence_result) { + usage_statistics::AppCounter count_of_rejections_duplicate_name( + policy::PolicyHandler::instance()->GetStatisticManager(), mobile_app_id, + usage_statistics::REJECTIONS_DUPLICATE_NAME); + ++count_of_rejections_duplicate_name; + } + SendResponse(false, coincidence_result); + return; + } + + if (IsApplicationWithSameAppIdRegistered()) { + SendResponse(false, mobile_apis::Result::DISALLOWED); + return; + } + + mobile_apis::Result::eType restriction_result = CheckRestrictions(); + if (mobile_apis::Result::SUCCESS != restriction_result) { + LOG4CXX_ERROR_EXT(logger_, "Param names restrictions check failed."); + SendResponse(false, restriction_result); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_INFO(logger_, + "Incoming register app interface has contains \t\n \\t \\n"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->RegisterApplication(message_); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "Application " << + msg_params[strings::app_name].asString() << + " hasn't been registered!"); + } else { + + // For resuming application need to restore hmi_app_id from resumeCtrl + const std::string mobile_app_id = msg_params[strings::app_id].asString(); + ResumeCtrl& resumer = ApplicationManagerImpl::instance()->resume_controller(); + + // there is side affect with 2 mobile app with the same mobile app_id + if (resumer.IsApplicationSaved(mobile_app_id)) { + app->set_hmi_application_id(resumer.GetHMIApplicationID(mobile_app_id)); + } else { + app->set_hmi_application_id( + ApplicationManagerImpl::instance()->GenerateNewHMIAppID()); + } + + app->set_is_media_application( + msg_params[strings::is_media_application].asBool()); + + if (msg_params.keyExists(strings::vr_synonyms)) { + app->set_vr_synonyms(msg_params[strings::vr_synonyms]); + } + + if (msg_params.keyExists(strings::ngn_media_screen_app_name)) { + app->set_ngn_media_screen_name( + msg_params[strings::ngn_media_screen_app_name]); + } + + if (msg_params.keyExists(strings::tts_name)) { + app->set_tts_name(msg_params[strings::tts_name]); + } + + if (msg_params.keyExists(strings::app_hmi_type)) { + app->set_app_types(msg_params[strings::app_hmi_type]); + + // check if app is NAVI + const int32_t is_navi_type = mobile_apis::AppHMIType::NAVIGATION; + const smart_objects::SmartObject& app_type = + msg_params.getElement(strings::app_hmi_type); + + for (size_t i = 0; i < app_type.length(); ++i) { + if (is_navi_type == app_type.getElement(i).asInt()) { + app->set_allowed_support_navigation(true); + } + } + } + + const connection_handler::DeviceHandle handle = app->device(); + // Add device to policy table and set device info, if any + std::string device_mac_address = + application_manager::MessageHelper::GetDeviceMacAddressForHandle(handle); + policy::DeviceParams dev_params; + application_manager::MessageHelper::GetDeviceInfoForHandle(handle, + &dev_params); + policy::DeviceInfo device_info; + device_info.connection_type = dev_params.device_connection_type; + if (msg_params.keyExists(strings::device_info)) { + FillDeviceInfo(&device_info); + } + + policy::PolicyHandler::instance()->SetDeviceInfo(device_mac_address, + device_info); + + SendRegisterAppInterfaceResponseToMobile(); + policy::PolicyHandler::instance()->PTExchangeAtRegistration(mobile_app_id); + } +} + +void RegisterAppInterfaceRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "RegisterAppInterfaceRequest::on_event"); + switch (event.id()) { + case hmi_apis::FunctionID::TTS_Speak: { + const smart_objects::SmartObject& message = event.smart_object(); + + mobile_apis::Result::eType tts_result = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + SendRegisterAppInterfaceResponseToMobile(tts_result); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + break; + } + } +} + +void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile( + mobile_apis::Result::eType result) { + smart_objects::SmartObject* params = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + ApplicationManagerImpl* app_manager = ApplicationManagerImpl::instance(); + const HMICapabilities& hmi_capabilities = app_manager->hmi_capabilities(); + const uint32_t key = connection_key(); + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(key); + + if (!application.valid()) { + LOG4CXX_ERROR(logger_, "There is no application for such connection key" << + key); + return; + } + + smart_objects::SmartObject& response_params = *params; + + response_params[strings::sync_msg_version][strings::major_version] = + APIVersion::kAPIV3; + response_params[strings::sync_msg_version][strings::minor_version] = + APIVersion::kAPIV0; + + response_params[strings::language] = hmi_capabilities.active_vr_language(); + response_params[strings::hmi_display_language] = + hmi_capabilities.active_ui_language(); + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + if (msg_params[strings::language_desired].asInt() != + hmi_capabilities.active_vr_language() || + msg_params[strings::hmi_display_language_desired].asInt() != + hmi_capabilities.active_ui_language()) { + + LOG4CXX_WARN_EXT( + logger_, + "Wrong language on registering application " << application->name()); + + LOG4CXX_ERROR_EXT( + logger_, + "vr " + << msg_params[strings::language_desired].asInt() + << " - " + << hmi_capabilities.active_vr_language() + << "ui " + << msg_params[strings::hmi_display_language_desired].asInt() + << " - " + << hmi_capabilities.active_ui_language()); + + result = mobile_apis::Result::WRONG_LANGUAGE; + } + + if (hmi_capabilities.display_capabilities()) { + response_params[hmi_response::display_capabilities] = + smart_objects::SmartObject(smart_objects::SmartType_Map); + + smart_objects::SmartObject& display_caps = + response_params[hmi_response::display_capabilities]; + + display_caps[hmi_response::display_type] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::display_type); + + display_caps[hmi_response::text_fields] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::text_fields); + + display_caps[hmi_response::image_fields] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::image_fields); + + display_caps[hmi_response::media_clock_formats] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::media_clock_formats); + + display_caps[hmi_response::templates_available] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::templates_available); + + display_caps[hmi_response::screen_params] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::screen_params); + + display_caps[hmi_response::num_custom_presets_available] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::num_custom_presets_available); + + if (hmi_capabilities.display_capabilities()->getElement( + hmi_response::image_capabilities).length() > 0) { + display_caps[hmi_response::graphic_supported] = true; + } else { + display_caps[hmi_response::graphic_supported] = false; + } + + display_caps[hmi_response::templates_available] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::templates_available); + + display_caps[hmi_response::screen_params] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::screen_params); + + display_caps[hmi_response::num_custom_presets_available] = + hmi_capabilities.display_capabilities()->getElement( + hmi_response::num_custom_presets_available); + } + + if (hmi_capabilities.button_capabilities()) { + response_params[hmi_response::button_capabilities] = + *hmi_capabilities.button_capabilities(); + } + if (hmi_capabilities.soft_button_capabilities()) { + response_params[hmi_response::soft_button_capabilities] = + *hmi_capabilities.soft_button_capabilities(); + } + if (hmi_capabilities.preset_bank_capabilities()) { + response_params[hmi_response::preset_bank_capabilities] = + *hmi_capabilities.preset_bank_capabilities(); + } + if (hmi_capabilities.hmi_zone_capabilities()) { + response_params[hmi_response::hmi_zone_capabilities] = + *hmi_capabilities.hmi_zone_capabilities(); + } + if (hmi_capabilities.speech_capabilities()) { + response_params[strings::speech_capabilities] = + *hmi_capabilities.speech_capabilities(); + } + if (hmi_capabilities.vr_capabilities()) { + response_params[strings::vr_capabilities] = + *hmi_capabilities.vr_capabilities(); + } + if (hmi_capabilities.audio_pass_thru_capabilities()) { + response_params[strings::audio_pass_thru_capabilities] = + *hmi_capabilities.audio_pass_thru_capabilities(); + } + if (hmi_capabilities.vehicle_type()) { + response_params[hmi_response::vehicle_type] = + *hmi_capabilities.vehicle_type(); + } + if (hmi_capabilities.prerecorded_speech()) { + response_params[strings::prerecorded_speech] = + *(hmi_capabilities.prerecorded_speech()); + } + + const std::vector<uint32_t>& diag_modes = + profile::Profile::instance()->supported_diag_modes(); + if (!diag_modes.empty()) { + std::vector<uint32_t>::const_iterator it = diag_modes.begin(); + uint32_t index = 0; + for (; it != diag_modes.end(); ++it) { + response_params[strings::supported_diag_modes][index] = *it; + ++index; + } + } + + ResumeCtrl& resumer = ApplicationManagerImpl::instance()->resume_controller(); + uint32_t hash_id = 0; + + const char* add_info = ""; + bool resumption = (*message_)[strings::msg_params].keyExists(strings::hash_id); + if (resumption) { + hash_id = (*message_)[strings::msg_params][strings::hash_id].asUInt(); + if (!resumer.CheckApplicationHash(application, hash_id)) { + LOG4CXX_WARN(logger_, "Hash does not matches"); + result = mobile_apis::Result::RESUME_FAILED; + add_info = "Hash does not matches"; + resumption = false; + } else if (!resumer.CheckPersistenceFilesForResumption(application)) { + LOG4CXX_WARN(logger_, "Persistent data is missed"); + result = mobile_apis::Result::RESUME_FAILED; + add_info = "Persistent data is missed"; + resumption = false; + } else { + add_info = " Resume Succeed"; + } + } + + SendResponse(true, result, add_info, params); + + MessageHelper::SendOnAppRegisteredNotificationToHMI(*(application.get()), + resumption); + + MessageHelper::SendChangeRegistrationRequestToHMI(application); + + if (result != mobile_apis::Result::RESUME_FAILED) { + resumer.StartResumption(application, hash_id); + } else { + resumer.StartResumptionOnlyHMILevel(application); + } +} + +mobile_apis::Result::eType +RegisterAppInterfaceRequest::CheckCoincidence() { + LOG4CXX_TRACE_ENTER(logger_); + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + + std::set<ApplicationSharedPtr>::const_iterator it = applications.begin(); + const std::string app_name = msg_params[strings::app_name].asString(); + + for (; applications.end() != it; ++it) { + + // name check + const std::string& cur_name = (*it)->name(); + if (!strcasecmp(app_name.c_str(), cur_name.c_str())) { + LOG4CXX_ERROR(logger_, "Application name is known already."); + return mobile_apis::Result::DUPLICATE_NAME; + } + + const smart_objects::SmartObject* vr = (*it)->vr_synonyms(); + const std::vector<smart_objects::SmartObject>* curr_vr = NULL; + if (NULL != vr) { + curr_vr = vr->asArray(); + CoincidencePredicateVR v(app_name); + + if (0 != std::count_if(curr_vr->begin(), curr_vr->end(), v)) { + LOG4CXX_ERROR(logger_, "Application name is known already."); + return mobile_apis::Result::DUPLICATE_NAME; + } + } + + // vr check + if (msg_params.keyExists(strings::vr_synonyms)) { + const std::vector<smart_objects::SmartObject>* new_vr = + msg_params[strings::vr_synonyms].asArray(); + + CoincidencePredicateVR v(cur_name); + if (0 != std::count_if(new_vr->begin(), new_vr->end(), v)) { + LOG4CXX_ERROR(logger_, "vr_synonyms duplicated with app_name ."); + return mobile_apis::Result::DUPLICATE_NAME; + } + } // end vr check + + } // application for end + + return mobile_apis::Result::SUCCESS; +} // method end + +mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckWithPolicyData() { + LOG4CXX_INFO(logger_, "CheckWithPolicyData"); + // TODO(AOleynik): Check is necessary to allow register application in case + // of disabled policy + // Remove this check, when HMI will support policy + if (!policy::PolicyHandler::instance()->PolicyEnabled()) { + return mobile_apis::Result::WARNINGS; + } + + smart_objects::SmartObject& message = *message_; + policy::StringArray app_nicknames; + policy::StringArray app_hmi_types; + + std::string mobile_app_id = message[strings::msg_params][strings::app_id].asString(); + const bool init_result = policy::PolicyHandler::instance()->GetInitialAppData( + mobile_app_id, &app_nicknames, &app_hmi_types); + + if (!init_result) { + LOG4CXX_ERROR(logger_, "Error during initial application data check."); + return mobile_apis::Result::INVALID_DATA; + } + + if (!app_nicknames.empty()) { + policy::StringArray::const_iterator it = std::find( + app_nicknames.begin(), app_nicknames.end(), + message[strings::msg_params][strings::app_name].asString()); + if (app_nicknames.end() == it) { + LOG4CXX_WARN(logger_, + "Application name was not found in nicknames list."); + //App should be unregistered, if its name is not present in nicknames list + usage_statistics::AppCounter count_of_rejections_nickname_mismatch( + policy::PolicyHandler::instance()->GetStatisticManager(), mobile_app_id, + usage_statistics::REJECTIONS_NICKNAME_MISMATCH); + ++count_of_rejections_nickname_mismatch; + return mobile_apis::Result::DISALLOWED; + } + } + + mobile_apis::Result::eType result = mobile_apis::Result::SUCCESS; + + // If AppHMIType is not included in policy - allow any type + if (!app_hmi_types.empty()) { + if (message[strings::msg_params].keyExists(strings::app_hmi_type)) { + // If AppHMITypes are partially same, the system should allow those listed + // in the policy table and send warning info on missed values + smart_objects::SmartArray app_types = + *(message[strings::msg_params][strings::app_hmi_type].asArray()); + + std::string log; + CheckMissedTypes checker(app_hmi_types, log); + std::for_each(app_types.begin(), app_types.end(), checker); + if (!log.empty()) { + response_info_ = "Following AppHMITypes are not present in policy " + "table:" + log; + result = mobile_apis::Result::WARNINGS; + } + } + // Replace AppHMITypes in request with values allowed by policy table + message[strings::msg_params][strings::app_hmi_type] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + + smart_objects::SmartObject& app_hmi_type = + message[strings::msg_params][strings::app_hmi_type]; + + AppHMITypeInserter inserter(app_hmi_type); + std::for_each(app_hmi_types.begin(), app_hmi_types.end(), inserter); + } + + return result; +} + +void RegisterAppInterfaceRequest::FillDeviceInfo( + policy::DeviceInfo* device_info) { + const std::string hardware = "hardware"; + const std::string firmware_rev = "firmwareRev"; + const std::string os = "os"; + const std::string os_ver = "osVersion"; + const std::string carrier = "carrier"; + const std::string max_number_rfcom_ports = "maxNumberRFCOMMPorts"; + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + const smart_objects::SmartObject& device_info_so = + msg_params[strings::device_info]; + + if (device_info_so.keyExists(hardware)) { + device_info->hardware = msg_params[strings::device_info][hardware].asString(); + } + if (device_info_so.keyExists(firmware_rev)) { + device_info->firmware_rev = msg_params[strings::device_info][firmware_rev].asString(); + } + if (device_info_so.keyExists(os)) { + device_info->os = device_info_so[os].asString(); + } + if (device_info_so.keyExists(os_ver)) { + device_info->os_ver = device_info_so[os_ver].asString(); + } + if (device_info_so.keyExists(carrier)) { + device_info->carrier = device_info_so[carrier].asString(); + } + if (device_info_so.keyExists(max_number_rfcom_ports)) { + device_info->max_number_rfcom_ports = + device_info_so[max_number_rfcom_ports].asInt(); + } +} + +mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckRestrictions() const { + + LOG4CXX_INFO(logger_, "RegisterAppInterfaceRequest::CheckRestrictions"); + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + const std::string& app_name = msg_params[strings::app_name].asString(); + + if (ClearParamName(app_name).empty()) { + printf("Application name is empty.\n"); + return mobile_apis::Result::INVALID_DATA; + } + + if ((app_name[0] == '\n') || + ((app_name[0] == '\\') && (app_name[1] == 'n'))) { + + printf("Application name has invalid characters."); + return mobile_apis::Result::INVALID_DATA; + } + + if (msg_params.keyExists(strings::tts_name)) { + + const smart_objects::SmartArray* tts = + msg_params[strings::tts_name].asArray(); + + smart_objects::SmartArray::const_iterator it = tts->begin(); + smart_objects::SmartArray::const_iterator it_end = tts->end(); + + for (; it != it_end; ++it) { + + const std::string& tts_name = (*it)[strings::text].asString(); + + if (ClearParamName(tts_name).empty()) { + printf("TTS value is empty."); + return mobile_apis::Result::INVALID_DATA; + } + + if ((tts_name[0] == '\n') || + ((tts_name[0] == '\\') && (tts_name[1] == 'n'))) { + + printf("TTS value(s) has invalid characters."); + return mobile_apis::Result::INVALID_DATA; + } + } + } + + return mobile_apis::Result::SUCCESS; +} + +std::string +RegisterAppInterfaceRequest::ClearParamName(std::string param_name) const { + + // Expecting for chars different from newlines and spaces in the appName + // + // There is an agreement, that "\n" is not allowed symbols, so we have to + // check for this case also + + std::string newline = "\\n"; + while (std::string::npos != param_name.find(newline)) { + param_name.erase(param_name.find(newline), newline.length()); + } + + std::string::iterator param_name_new_end = + std::remove_if(param_name.begin(), param_name.end(), ::isspace); + + return std::string(param_name.begin(), param_name_new_end); +} + +bool RegisterAppInterfaceRequest::IsApplicationWithSameAppIdRegistered() { + + LOG4CXX_INFO(logger_, "RegisterAppInterfaceRequest::" + "IsApplicationWithSameAppIdRegistered"); + + const std::string mobile_app_id = (*message_)[strings::msg_params] + [strings::app_id].asString(); + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> applications = accessor.applications(); + + std::set<ApplicationSharedPtr>::const_iterator it = applications.begin(); + std::set<ApplicationSharedPtr>::const_iterator it_end = applications.end(); + + for (; it != it_end; ++it) { + if (mobile_app_id == (*it)->mobile_app_id()->asString()) { + return true; + } + } + + return false; +} + +bool RegisterAppInterfaceRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "RegisterAppInterfaceRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + str = (*message_)[strings::msg_params][strings::app_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid app_name syntax check failed"); + return true; + } + + + if ((*message_)[strings::msg_params].keyExists(strings::tts_name)) { + const smart_objects::SmartArray* tn_array = + (*message_)[strings::msg_params][strings::tts_name].asArray(); + + smart_objects::SmartArray::const_iterator it_tn = tn_array->begin(); + smart_objects::SmartArray::const_iterator it_tn_end = tn_array->end(); + + for (; it_tn != it_tn_end; ++it_tn) { + str = (*it_tn)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid tts_name syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params]. + keyExists(strings::ngn_media_screen_app_name)) { + str = (*message_)[strings::msg_params] + [strings::ngn_media_screen_app_name].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid ngn_media_screen_app_name syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::vr_synonyms)) { + const smart_objects::SmartArray* vs_array = + (*message_)[strings::msg_params][strings::vr_synonyms].asArray(); + + smart_objects::SmartArray::const_iterator it_vs = vs_array->begin(); + smart_objects::SmartArray::const_iterator it_vs_end = vs_array->end(); + + for (; it_vs != it_vs_end; ++it_vs) { + str = (*it_vs).asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_synonyms syntax check failed"); + return true; + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::hash_id)) { + str = (*message_)[strings::msg_params][strings::hash_id].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid hash_id syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::device_info)) { + + if ((*message_)[strings::msg_params][strings::device_info]. + keyExists(strings::hardware)) { + str = (*message_)[strings::msg_params] + [strings::device_info][strings::hardware].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid device_info hardware syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params][strings::device_info]. + keyExists(strings::firmware_rev)) { + str = (*message_)[strings::msg_params] + [strings::device_info][strings::firmware_rev].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid device_info firmware_rev syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params][strings::device_info]. + keyExists(strings::os)) { + str = (*message_)[strings::msg_params] + [strings::device_info][strings::os].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid device_info os syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params][strings::device_info]. + keyExists(strings::os_version)) { + str = (*message_)[strings::msg_params] + [strings::device_info][strings::os_version].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid device_info os_version syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params][strings::device_info]. + keyExists(strings::carrier)) { + str = (*message_)[strings::msg_params] + [strings::device_info][strings::carrier].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid device_info carrier syntax check failed"); + return true; + } + } + + } + + if ((*message_)[strings::msg_params].keyExists(strings::app_id)) { + str = (*message_)[strings::msg_params][strings::app_id].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid app_id syntax check failed"); + return true; + } + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc b/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc new file mode 100644 index 0000000000..fe6f3a925a --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/register_app_interface_response.cc @@ -0,0 +1,93 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/register_app_interface_response.h" +#include "interfaces/MOBILE_API.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/application_manager_impl.h" +#include "connection_handler/connection_handler.h" + +namespace application_manager { + +namespace commands { + +void RegisterAppInterfaceResponse::Run() { + LOG4CXX_INFO(logger_, "RegisterAppInterfaceResponse::Run"); + + mobile_apis::Result::eType result_code = mobile_apis::Result::INVALID_ENUM; + bool success = (*message_)[strings::msg_params][strings::success].asBool(); + bool last_message = !success; + // Do not close connection in case of APPLICATION_NOT_REGISTERED despite it is an error + if (!success && (*message_)[strings::msg_params].keyExists(strings::result_code)) { + result_code = static_cast<mobile_apis::Result::eType>( + (*message_)[strings::msg_params][strings::result_code].asInt()); + if (result_code == mobile_apis::Result::APPLICATION_REGISTERED_ALREADY) { + last_message = false; + } + } + + SendResponse(success, result_code, last_message); + + // Add registered application to the policy db right after response sent to + // mobile to be able to check all other API according to app permissions + uint32_t connection_key = + (*message_)[strings::params][strings::connection_key].asUInt(); + application_manager::ApplicationConstSharedPtr app = + application_manager::ApplicationManagerImpl::instance()-> + application(connection_key); + if (app.valid()) { + policy::PolicyHandler *policy_handler = policy::PolicyHandler::instance(); + std::string mobile_app_id = app->mobile_app_id()->asString(); + policy_handler->AddApplication(mobile_app_id); + SetHeartBeatTimeout(connection_key, mobile_app_id); + } +} + +void RegisterAppInterfaceResponse::SetHeartBeatTimeout( + uint32_t connection_key, const std::string& mobile_app_id) { + LOG4CXX_TRACE_ENTER(logger_); + policy::PolicyHandler *policy_handler = policy::PolicyHandler::instance(); + if (policy_handler->PolicyEnabled()) { + const int32_t timeout = policy_handler->HeartBeatTimeout(mobile_app_id); + if (timeout > 0) { + application_manager::ApplicationManagerImpl::instance()-> + connection_handler()->SetHeartBeatTimeout(connection_key, timeout); + } + } else { + LOG4CXX_INFO(logger_, "Policy is turn off"); + } + LOG4CXX_TRACE_EXIT(logger_); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/reset_global_properties_request.cc b/src/components/application_manager/src/commands/mobile/reset_global_properties_request.cc new file mode 100644 index 0000000000..5e62b789d8 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/reset_global_properties_request.cc @@ -0,0 +1,302 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/reset_global_properties_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "config_profile/profile.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ResetGlobalPropertiesRequest::ResetGlobalPropertiesRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message), + is_ui_send_(false), + is_tts_send_(false), + is_ui_received_(false), + is_tts_received_(false), + ui_result_(hmi_apis::Common_Result::INVALID_ENUM), + tts_result_(hmi_apis::Common_Result::INVALID_ENUM) { +} + +ResetGlobalPropertiesRequest::~ResetGlobalPropertiesRequest() { +} + +void ResetGlobalPropertiesRequest::Run() { + LOG4CXX_INFO(logger_, "ResetGlobalPropertiesRequest::Run"); + + uint32_t app_id = (*message_)[strings::params][strings::connection_key].asUInt(); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "No application associated with session key"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + size_t obj_length = (*message_)[strings::msg_params][strings::properties] + .length(); + //if application waits for sending ttsGlobalProperties need to remove this + //application from tts_global_properties_app_list_ + LOG4CXX_INFO(logger_, "RemoveAppFromTTSGlobalPropertiesList"); + ApplicationManagerImpl::instance()->RemoveAppFromTTSGlobalPropertiesList( + app_id); + + bool helpt_promt = false; + bool timeout_prompt = false; + bool vr_help_title_items = false; + bool menu_name = false; + bool menu_icon = false; + bool is_key_board_properties = false; + int number_of_reset_vr = 0; + mobile_apis::GlobalProperty::eType global_property = + mobile_apis::GlobalProperty::INVALID_ENUM; + + for (size_t i = 0; i < obj_length; ++i) { + global_property = static_cast<mobile_apis::GlobalProperty::eType>( + (*message_)[strings::msg_params][strings::properties][i].asInt()); + + if (mobile_apis::GlobalProperty::HELPPROMPT == global_property) { + helpt_promt = ResetHelpPromt(app); + } else if (mobile_apis::GlobalProperty::TIMEOUTPROMPT == global_property) { + timeout_prompt = ResetTimeoutPromt(app); + } else if (((mobile_apis::GlobalProperty::VRHELPTITLE == global_property) || + (mobile_apis::GlobalProperty::VRHELPITEMS == global_property)) && + (0 == number_of_reset_vr)) { + ++number_of_reset_vr; + vr_help_title_items = ResetVrHelpTitleItems(app); + } else if (mobile_apis::GlobalProperty::MENUNAME == global_property) { + menu_name = true; + } else if (mobile_apis::GlobalProperty::MENUICON == global_property) { + menu_icon = true; + } else if (mobile_apis::GlobalProperty::KEYBOARDPROPERTIES == global_property) { + is_key_board_properties = true; + } + } + + if (vr_help_title_items || menu_name || menu_icon || is_key_board_properties) { + is_ui_send_ = true; + } + + if (timeout_prompt || helpt_promt) { + is_tts_send_ = true; + } + + app->set_reset_global_properties_active(true); + + if (vr_help_title_items || menu_name || menu_icon || is_key_board_properties) { + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (vr_help_title_items) { + smart_objects::SmartObject* vr_help = MessageHelper::CreateAppVrHelp(app); + if (!vr_help) { + return; + } + msg_params = *vr_help; + } + if (menu_name) { + msg_params[hmi_request::menu_title] = ""; + app->set_menu_title(msg_params[hmi_request::menu_title]); + } + //TODO(DT): clarify the sending parameter menuIcon + //if (menu_icon) { + //} + if (is_key_board_properties) { + smart_objects::SmartObject key_board_properties = smart_objects:: + SmartObject(smart_objects::SmartType_Map); + key_board_properties[strings::language] = static_cast<int32_t> + (hmi_apis::Common_Language::EN_US); + key_board_properties[hmi_request::keyboard_layout] = static_cast<int32_t> + (hmi_apis::Common_KeyboardLayout::QWERTY); + + // Look for APPLINK-4432 for details. + /*smart_objects::SmartObject limited_character_list = smart_objects::SmartObject( + smart_objects::SmartType_Array); + limited_character_list[0] = ""; + key_board_properties[hmi_request::limited_character_list] = + limited_character_list;*/ + + key_board_properties[hmi_request::auto_complete_text] = ""; + msg_params[hmi_request::keyboard_properties] = key_board_properties; + } + + msg_params[strings::app_id] = app->app_id(); + SendHMIRequest(hmi_apis::FunctionID::UI_SetGlobalProperties, + &msg_params, true); + } + + if (timeout_prompt || helpt_promt) { + // create ui request + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (helpt_promt) { + msg_params[strings::help_prompt] = (*app->help_prompt()); + } + + if (timeout_prompt) { + msg_params[strings::timeout_prompt] = (*app->timeout_prompt()); + } + + msg_params[strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::TTS_SetGlobalProperties, + &msg_params, true); + } +} + +bool ResetGlobalPropertiesRequest::ResetHelpPromt( + application_manager::ApplicationSharedPtr app) { + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "Null pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return false; + } + smart_objects::SmartObject so_help_prompt = smart_objects::SmartObject( + smart_objects::SmartType_Array); + app->set_help_prompt(so_help_prompt); + return true; +} + +bool ResetGlobalPropertiesRequest::ResetTimeoutPromt( + application_manager::ApplicationSharedPtr const app) { + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "Null pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return false; + } + + const std::vector<std::string>& time_out_promt = profile::Profile::instance() + ->time_out_promt(); + + smart_objects::SmartObject so_time_out_promt = smart_objects::SmartObject( + smart_objects::SmartType_Array); + + for (uint32_t i = 0; i < time_out_promt.size(); ++i) { + smart_objects::SmartObject timeoutPrompt = smart_objects::SmartObject( + smart_objects::SmartType_Map); + timeoutPrompt[strings::text] = time_out_promt[i]; + timeoutPrompt[strings::type] = hmi_apis::Common_SpeechCapabilities::SC_TEXT; + so_time_out_promt[i] = timeoutPrompt; + } + + app->set_timeout_prompt(so_time_out_promt); + + return true; +} + +bool ResetGlobalPropertiesRequest::ResetVrHelpTitleItems( + application_manager::ApplicationSharedPtr const app) { + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "Null pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return false; + } + app->reset_vr_help_title(); + app->reset_vr_help(); + + return true; +} + +void ResetGlobalPropertiesRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ResetGlobalPropertiesRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_SetGlobalProperties: { + LOG4CXX_INFO(logger_, "Received UI_SetGlobalProperties event"); + is_ui_received_ = true; + ui_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + case hmi_apis::FunctionID::TTS_SetGlobalProperties: { + LOG4CXX_INFO(logger_, "Received TTS_SetGlobalProperties event"); + is_tts_received_ = true; + tts_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } + + if (!IsPendingResponseExist()) { + bool result = ((hmi_apis::Common_Result::SUCCESS == ui_result_) + && (hmi_apis::Common_Result::SUCCESS == tts_result_ || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == tts_result_)) + || ((hmi_apis::Common_Result::SUCCESS == ui_result_) + && (hmi_apis::Common_Result::INVALID_ENUM == tts_result_)) + || ((hmi_apis::Common_Result::INVALID_ENUM == ui_result_) + && (hmi_apis::Common_Result::SUCCESS == tts_result_)); + + mobile_apis::Result::eType result_code; + const char* return_info = NULL; + + if (result) { + if (hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == tts_result_) { + result_code = mobile_apis::Result::WARNINGS; + return_info = std::string("Unsupported phoneme type sent in a prompt").c_str(); + } else { + result_code = static_cast<mobile_apis::Result::eType>( + std::max(ui_result_, tts_result_)); + } + } else { + result_code = static_cast<mobile_apis::Result::eType>( + std::max(ui_result_, tts_result_)); + } + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + SendResponse(result, static_cast<mobile_apis::Result::eType>(result_code), + return_info, &(message[strings::msg_params])); + application->UpdateHash(); + } +} + +bool ResetGlobalPropertiesRequest::IsPendingResponseExist() { + return is_ui_send_ != is_ui_received_ || is_tts_send_ != is_tts_received_; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/reset_global_properties_response.cc b/src/components/application_manager/src/commands/mobile/reset_global_properties_response.cc new file mode 100644 index 0000000000..aeacabf9d5 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/reset_global_properties_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/reset_global_properties_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +ResetGlobalPropertiesResponse::ResetGlobalPropertiesResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +ResetGlobalPropertiesResponse::~ResetGlobalPropertiesResponse() { +} + +void ResetGlobalPropertiesResponse::Run() { + LOG4CXX_INFO(logger_, "ResetGlobalPropertiesResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc b/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc new file mode 100644 index 0000000000..5b3cfa67ac --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/scrollable_message_request.cc @@ -0,0 +1,155 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include "application_manager/commands/mobile/scrollable_message_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ScrollableMessageRequest::ScrollableMessageRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { + subscribe_on_event(hmi_apis::FunctionID::UI_OnResetTimeout); +} + +ScrollableMessageRequest::~ScrollableMessageRequest() { +} + +bool ScrollableMessageRequest::Init() { + + /* Timeout in milliseconds. + If omitted a standard value of 10000 milliseconds is used.*/ + if ((*message_)[strings::msg_params].keyExists(strings::timeout)) { + default_timeout_ = + (*message_)[strings::msg_params][strings::timeout].asUInt(); + } else { + const int32_t def_value = 30000; + default_timeout_ = def_value; + } + + return true; +} + +void ScrollableMessageRequest::Run() { + LOG4CXX_INFO(logger_, "ScrollableMessageRequest::Run"); + + ApplicationSharedPtr app = application_manager::ApplicationManagerImpl::instance() + ->application((*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + //ProcessSoftButtons checks strings on the contents incorrect character + + mobile_apis::Result::eType processing_result = + MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app); + + if (mobile_apis::Result::SUCCESS != processing_result) { + LOG4CXX_ERROR(logger_, "Wrong soft buttons parameters!"); + SendResponse(false, processing_result); + return; + } + + + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[hmi_request::message_text][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::scrollableMessageBody); + msg_params[hmi_request::message_text][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::scroll_message_body]; + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::timeout] = default_timeout_; + + if ((*message_)[strings::msg_params].keyExists(strings::soft_buttons)) { + msg_params[strings::soft_buttons] = + (*message_)[strings::msg_params][strings::soft_buttons]; + MessageHelper::SubscribeApplicationToSoftButton( + (*message_)[strings::msg_params], app, function_id()); + } + + SendHMIRequest(hmi_apis::FunctionID::UI_ScrollableMessage, &msg_params, true); +} + +void ScrollableMessageRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ScrollableMessageRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_OnResetTimeout: { + LOG4CXX_INFO(logger_, "Received UI_OnResetTimeout event"); + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + break; + } + case hmi_apis::FunctionID::UI_ScrollableMessage: { + LOG4CXX_INFO(logger_, "Received UI_ScrollableMessage event"); + + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType> + (message[strings::params][hmi_response::code].asInt()); + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + bool result = false; + if (mobile_apis::Result::SUCCESS == result_code || + mobile_apis::Result::ABORTED == result_code) { + result = true; + } else if ((mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code) && + hmi_capabilities.is_ui_cooperating()) { + result = true; + } + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + break; + } + } +} + +} // namespace commands +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/mobile/scrollable_message_response.cc b/src/components/application_manager/src/commands/mobile/scrollable_message_response.cc new file mode 100644 index 0000000000..d9692359d0 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/scrollable_message_response.cc @@ -0,0 +1,64 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/scrollable_message_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +namespace commands { + +ScrollableMessageResponse::ScrollableMessageResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +void ScrollableMessageResponse::Run() { + LOG4CXX_INFO(logger_, "ScrollableMessageResponse::Run"); + mobile_apis::Result::eType result_code = static_cast<mobile_apis::Result::eType>( + (*message_)[strings::msg_params][strings::result_code].asInt()); + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asInt()); + if ((mobile_apis::Result::REJECTED != result_code) && application) { + application->UnsubscribeFromSoftButtons( + (*message_)[strings::params][strings::function_id].asInt()); + } + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/send_location_request.cc b/src/components/application_manager/src/commands/mobile/send_location_request.cc new file mode 100644 index 0000000000..b5c2e8a9a5 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/send_location_request.cc @@ -0,0 +1,166 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/send_location_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +SendLocationRequest::SendLocationRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SendLocationRequest::~SendLocationRequest() { +} + +void SendLocationRequest::Run() { + LOG4CXX_INFO(logger_, "SendLocationRequest::Run"); + + ApplicationSharedPtr app = application_manager::ApplicationManagerImpl::instance() + ->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR_EXT( + logger_, "An application " << app->name() << " is not registered."); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, "Strings contain invalid characters"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if ((*message_)[strings::msg_params].keyExists(strings::location_image)) { + mobile_apis::Result::eType verification_result = + mobile_apis::Result::SUCCESS; + verification_result = MessageHelper::VerifyImage( + (*message_)[strings::msg_params][strings::location_image], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!"); + SendResponse(false, verification_result); + return; + } + } + + SendHMIRequest(hmi_apis::FunctionID::Navigation_SendLocation, + &((*message_)[strings::msg_params]), + true); +} + +void SendLocationRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SendLocationRquest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + switch (event.id()) { + case hmi_apis::FunctionID::Navigation_SendLocation: { + LOG4CXX_INFO(logger_, "Received Navigation_SendLocation event"); + mobile_apis::Result::eType result_code = GetMobileResultCode( + static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asUInt())); + bool result = mobile_apis::Result::SUCCESS == result_code; + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + break; + } + } +} + +bool SendLocationRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "SendLocationRquest::IsWhiteSpaceExist"); + const char* str; + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + if (msg_params.keyExists(strings::location_name)) { + str = msg_params[strings::location_name].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "parameter locationName contains invalid character"); + return true; + } + } + + if (msg_params.keyExists(strings::location_description)) { + str = msg_params[strings::location_description].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "parameter locationDescription contains invalid character"); + return true; + } + } + + if (msg_params.keyExists(strings::address_lines)) { + const smart_objects::SmartArray* al_array = + msg_params[strings::address_lines].asArray(); + smart_objects::SmartArray::const_iterator it_al = al_array->begin(); + smart_objects::SmartArray::const_iterator it_al_end = al_array->end(); + for (; it_al != it_al_end; ++it_al) { + str = (*it_al).asCharArray(); + if(!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "parameter address_lines contains invalid character"); + return true; + } + } + } + + if (msg_params.keyExists(strings::phone_number)) { + str = msg_params[strings::phone_number].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "parameter phoneNumber contains invalid character"); + return true; + } + } + + if (msg_params.keyExists(strings::location_image)) { + str = msg_params[strings::location_image][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "parameter value in locationImage contains invalid character"); + return true; + } + } + + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/send_location_response.cc b/src/components/application_manager/src/commands/mobile/send_location_response.cc new file mode 100644 index 0000000000..a13b67dc06 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/send_location_response.cc @@ -0,0 +1,58 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/send_location_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +SendLocationResponse::SendLocationResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SendLocationResponse::~SendLocationResponse() { +} + +void SendLocationResponse::Run() { + LOG4CXX_INFO(logger_, "SendLocationResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_display_layout_request.cc b/src/components/application_manager/src/commands/mobile/set_display_layout_request.cc new file mode 100644 index 0000000000..60a2583287 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_display_layout_request.cc @@ -0,0 +1,123 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_display_layout_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + + +namespace application_manager { + +namespace commands { + +SetDisplayLayoutRequest::SetDisplayLayoutRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SetDisplayLayoutRequest::~SetDisplayLayoutRequest() { +} + +void SetDisplayLayoutRequest::Run() { + LOG4CXX_INFO(logger_, "SetDisplayLayoutRequest::Run"); + ApplicationConstSharedPtr app = ApplicationManagerImpl::instance() + ->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + (*message_)[strings::msg_params][strings::app_id] = app->app_id(); + SendHMIRequest(hmi_apis::FunctionID::UI_SetDisplayLayout, + &((*message_)[strings::msg_params]), true); + +} + +void SetDisplayLayoutRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SetDisplayLayoutRequest::on_event"); + + const smart_objects::SmartObject& message = event.smart_object(); + switch (event.id()) { + case hmi_apis::FunctionID::UI_SetDisplayLayout: { + LOG4CXX_INFO(logger_, "Received UI_SetDisplayLayout event"); + + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + bool response_success = mobile_apis::Result::SUCCESS == result_code; + if (response_success) { + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + if (message[strings::msg_params].keyExists(hmi_response::display_capabilities)) { + hmi_capabilities.set_display_capabilities( + message[strings::msg_params][hmi_response::display_capabilities]); + } + + if (message[strings::msg_params].keyExists( + hmi_response::soft_button_capabilities)) { + if (message[strings::msg_params][hmi_response::soft_button_capabilities].getType() == + smart_objects::SmartType_Array) { + hmi_capabilities.set_soft_button_capabilities( + message[strings::msg_params][hmi_response::soft_button_capabilities][0]); + } else { + hmi_capabilities.set_soft_button_capabilities( + message[strings::msg_params][hmi_response::soft_button_capabilities]); + } + } + + if (message[strings::msg_params].keyExists(hmi_response::button_capabilities)) { + hmi_capabilities.set_button_capabilities( + message[strings::msg_params][hmi_response::button_capabilities]); + } + + if (message[strings::msg_params].keyExists(hmi_response::preset_bank_capabilities)) { + hmi_capabilities.set_preset_bank_capabilities( + message[strings::msg_params][hmi_response::preset_bank_capabilities]); + } + + } + SendResponse(response_success, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_display_layout_response.cc b/src/components/application_manager/src/commands/mobile/set_display_layout_response.cc new file mode 100644 index 0000000000..51f8c1f35b --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_display_layout_response.cc @@ -0,0 +1,59 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_display_layout_response.h" +#include "application_manager/application_impl.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SetDisplayLayoutResponse::SetDisplayLayoutResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SetDisplayLayoutResponse::~SetDisplayLayoutResponse() { +} + +void SetDisplayLayoutResponse::Run() { + LOG4CXX_INFO(logger_, "SetDisplayLayoutResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); + +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_global_properties_request.cc b/src/components/application_manager/src/commands/mobile/set_global_properties_request.cc new file mode 100644 index 0000000000..f7216c818c --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_global_properties_request.cc @@ -0,0 +1,515 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include <algorithm> +#include "application_manager/commands/mobile/set_global_properties_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +SetGlobalPropertiesRequest::SetGlobalPropertiesRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message), + is_ui_send_(false), + is_tts_send_(false), + is_ui_received_(false), + is_tts_received_(false), + ui_result_(hmi_apis::Common_Result::INVALID_ENUM), + tts_result_(hmi_apis::Common_Result::INVALID_ENUM) { +} + +SetGlobalPropertiesRequest::~SetGlobalPropertiesRequest() { +} + +void SetGlobalPropertiesRequest::Run() { + LOG4CXX_INFO(logger_, "SetGlobalPropertiesRequest::Run"); + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + uint32_t app_id = + (*message_)[strings::params][strings::connection_key].asUInt(); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(app_id); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "No application associated with session key"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (!ValidateConditionalMandatoryParameters(msg_params)) { + SendResponse(false, + mobile_apis::Result::INVALID_DATA, + "There are no parameters present in request."); + return; + } + + mobile_apis::Result::eType verification_result = mobile_apis::Result::SUCCESS; + + if ((*message_)[strings::msg_params].keyExists(strings::menu_icon)) { + verification_result = MessageHelper::VerifyImage( + (*message_)[strings::msg_params][strings::menu_icon], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR_EXT( + logger_, + "MessageHelper::VerifyImage return " << verification_result); + SendResponse(false, verification_result); + return; + } + } + // Check for image file(s) in vrHelpItem + if ((*message_)[strings::msg_params].keyExists(strings::vr_help)) { + if (mobile_apis::Result::SUCCESS != MessageHelper::VerifyImageVrHelpItems( + (*message_)[strings::msg_params][strings::vr_help], app)) { + LOG4CXX_ERROR_EXT( + logger_, + "MessageHelper::VerifyImage return INVALID_DATA!" ); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + } + + if (IsWhiteSpaceExist()) { + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + //if application waits for sending ttsGlobalProperties need to remove this + //application from tts_global_properties_app_list_ + LOG4CXX_INFO(logger_, "RemoveAppFromTTSGlobalPropertiesList"); + ApplicationManagerImpl::instance()->RemoveAppFromTTSGlobalPropertiesList( + app_id); + bool is_help_prompt_present = msg_params.keyExists(strings::help_prompt); + bool is_timeout_prompt_present = msg_params.keyExists( + strings::timeout_prompt); + bool is_vr_help_title_present = msg_params.keyExists(strings::vr_help_title); + bool is_vr_help_present = msg_params.keyExists(strings::vr_help); + bool is_menu_title_present = msg_params.keyExists(hmi_request::menu_title); + bool is_menu_icon_present = msg_params.keyExists(hmi_request::menu_icon); + bool is_keyboard_props_present = + msg_params.keyExists(hmi_request::keyboard_properties); + + // Media-only applications support API v2.1 with less parameters + // Code deleted according to APPLINK-6119 APPLINK-6133 + // Not sure that it is right + +// if (!app->allowed_support_navigation() && +// (is_keyboard_props_present || +// is_menu_icon_present || +// is_menu_title_present) +// ) { +// const std::string app_type = +// app->is_media_application() ? "media" : "non-media"; + +// const std::string message = +// "There are too many parameters for "+app_type+" application."; +// SendResponse(false, +// mobile_apis::Result::INVALID_DATA, +// message.c_str()); +// return; +// } + + if ((is_vr_help_title_present && is_vr_help_present) || + (!is_vr_help_title_present && !is_vr_help_present)) { + is_ui_send_ = true; + } + + if (is_help_prompt_present || is_timeout_prompt_present) { + is_tts_send_ = true; + } + + if (is_vr_help_title_present && is_vr_help_present) { + // check vrhelpitem position index + if (!CheckVrHelpItemsOrder()) { + LOG4CXX_ERROR(logger_, "Request rejected"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + app->set_vr_help_title( + msg_params.getElement(strings::vr_help_title)); + app->set_vr_help( + msg_params.getElement(strings::vr_help)); + + smart_objects::SmartObject params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + + params[strings::vr_help_title] = (*app->vr_help_title()); + params[strings::vr_help] = (*app->vr_help()); + params[strings::app_id] = app->app_id(); + if (is_menu_title_present) { + + params[hmi_request::menu_title] = + msg_params[hmi_request::menu_title].asString(); + app->set_menu_title(msg_params[hmi_request::menu_title]); + } + if (is_menu_icon_present) { + + params[hmi_request::menu_icon] = + msg_params[hmi_request::menu_icon]; + app->set_menu_icon(msg_params[hmi_request::menu_icon]); + } + if (is_keyboard_props_present) { + + params[hmi_request::keyboard_properties] = + msg_params[hmi_request::keyboard_properties]; + app->set_keyboard_props(msg_params[hmi_request::keyboard_properties]); + } + + SendHMIRequest(hmi_apis::FunctionID::UI_SetGlobalProperties, + ¶ms, true); + } else if (!is_vr_help_title_present && !is_vr_help_present) { + const CommandsMap& cmdMap = app->commands_map(); + CommandsMap::const_iterator command_it = cmdMap.begin(); + + int32_t index = 0; + smart_objects::SmartObject vr_help_items; + for (; cmdMap.end() != command_it; ++command_it) { + if (false == (*command_it->second).keyExists(strings::vr_commands)) { + LOG4CXX_ERROR(logger_, "VR synonyms are empty"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + // use only first + vr_help_items[index][strings::position] = (index + 1); + vr_help_items[index++][strings::text] = + (*command_it->second)[strings::vr_commands][0]; + } + + app->set_vr_help_title(smart_objects::SmartObject(app->name())); + + smart_objects::SmartObject params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + + params[strings::vr_help_title] = (*app->vr_help_title()); + if (vr_help_items.length() > 0) { + app->set_vr_help(vr_help_items); + params[strings::vr_help] = (*app->vr_help()); + } + params[strings::app_id] = app->app_id(); + if (is_menu_title_present) { + + params[hmi_request::menu_title] = + msg_params[hmi_request::menu_title].asString(); + app->set_menu_title(msg_params[hmi_request::menu_title]); + } + if (is_menu_icon_present) { + + params[hmi_request::menu_icon] = + msg_params[hmi_request::menu_icon]; + app->set_menu_icon(msg_params[hmi_request::menu_icon]); + } + if (is_keyboard_props_present) { + + params[hmi_request::keyboard_properties] = + msg_params[hmi_request::keyboard_properties]; + app->set_keyboard_props(msg_params[hmi_request::keyboard_properties]); + } + + SendHMIRequest(hmi_apis::FunctionID::UI_SetGlobalProperties, + ¶ms, true); + } else { + LOG4CXX_ERROR(logger_, "Request rejected"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + + // check TTS params + if (is_help_prompt_present || is_timeout_prompt_present) { + smart_objects::SmartObject params = + smart_objects::SmartObject(smart_objects::SmartType_Map); + + if (is_help_prompt_present) { + app->set_help_prompt( + msg_params.getElement(strings::help_prompt)); + params[strings::help_prompt] = (*app->help_prompt()); + } + + if (is_timeout_prompt_present) { + app->set_timeout_prompt( + msg_params.getElement(strings::timeout_prompt)); + params[strings::timeout_prompt] = (*app->timeout_prompt()); + } + + params[strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::TTS_SetGlobalProperties, + ¶ms, true); + } +} + +bool SetGlobalPropertiesRequest::CheckVrHelpItemsOrder() { + const smart_objects::SmartObject vr_help = (*message_)[strings::msg_params] + .getElement(strings::vr_help); + + // vr help item start position must be 1 + const uint32_t vr_help_item_start_position = 1; + + if (vr_help_item_start_position != + vr_help.getElement(0).getElement(strings::position).asUInt()) { + LOG4CXX_ERROR(logger_, "VR help items start position is wrong"); + return false; + } + + // Check if VR Help Items contains sequential positionss + size_t i = 0; + for (size_t j = 1; j < vr_help.length(); ++i, ++j) { + if ((vr_help.getElement(i).getElement(strings::position).asInt() + 1) + != vr_help.getElement(j).getElement(strings::position).asInt()) { + LOG4CXX_ERROR(logger_, "VR help items order is wrong"); + return false; + } + } + + return true; +} + +void SetGlobalPropertiesRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SetGlobalPropertiesRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application(CommandRequestImpl::connection_key()); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_SetGlobalProperties: { + LOG4CXX_INFO(logger_, "Received UI_SetGlobalProperties event"); + is_ui_received_ = true; + ui_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + case hmi_apis::FunctionID::TTS_SetGlobalProperties: { + LOG4CXX_INFO(logger_, "Received TTS_SetGlobalProperties event"); + is_tts_received_ = true; + tts_result_ = static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } + + if (!IsPendingResponseExist()) { + bool result = ((hmi_apis::Common_Result::SUCCESS == ui_result_) + && (hmi_apis::Common_Result::SUCCESS == tts_result_ || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == tts_result_)) + || ((hmi_apis::Common_Result::SUCCESS == ui_result_ || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == ui_result_) + && (hmi_apis::Common_Result::INVALID_ENUM == tts_result_)) + || ((hmi_apis::Common_Result::INVALID_ENUM == ui_result_ || + hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == ui_result_) + && (hmi_apis::Common_Result::SUCCESS == tts_result_)); + + mobile_apis::Result::eType result_code; + const char* return_info = NULL; + + if (result) { + if (hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == tts_result_) { + result_code = mobile_apis::Result::WARNINGS; + return_info = + std::string("Unsupported phoneme type sent in a prompt").c_str(); + } else { + result_code = static_cast<mobile_apis::Result::eType>( + std::max(ui_result_, tts_result_)); + } + } else { + result_code = static_cast<mobile_apis::Result::eType>( + std::max(ui_result_, tts_result_)); + } + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + SendResponse(result, static_cast<mobile_apis::Result::eType>(result_code), + return_info, &(message[strings::msg_params])); + application->UpdateHash(); + } +} + +bool SetGlobalPropertiesRequest::IsPendingResponseExist() { + + return is_ui_send_ != is_ui_received_ || is_tts_send_ != is_tts_received_; +} + +bool SetGlobalPropertiesRequest::ValidateConditionalMandatoryParameters( + const smart_objects::SmartObject& params) { + return params.keyExists(strings::help_prompt) + || params.keyExists(strings::timeout_prompt) + || params.keyExists(strings::vr_help_title) + || params.keyExists(strings::vr_help) + || params.keyExists(strings::menu_title) + || params.keyExists(strings::menu_icon) + || params.keyExists(strings::keyboard_properties); +} + +bool SetGlobalPropertiesRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "SetGlobalPropertiesRequest::IsWhiteSpaceExist"); + const char* str; + + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + if (msg_params.keyExists(strings::help_prompt)) { + const smart_objects::SmartArray* hp_array = + msg_params[strings::help_prompt].asArray(); + + smart_objects::SmartArray::const_iterator it_hp = hp_array->begin(); + smart_objects::SmartArray::const_iterator it_hp_end = hp_array->end(); + + for (; it_hp != it_hp_end; ++it_hp) { + str = (*it_hp)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid help_prompt syntax check failed"); + return true; + } + } + } + + if (msg_params.keyExists(strings::timeout_prompt)) { + const smart_objects::SmartArray* tp_array = + msg_params[strings::timeout_prompt].asArray(); + + smart_objects::SmartArray::const_iterator it_tp = tp_array->begin(); + smart_objects::SmartArray::const_iterator it_tp_end = tp_array->end(); + + for (; it_tp != it_tp_end; ++it_tp) { + str = (*it_tp)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid timeout_prompt syntax check failed"); + return true; + } + } + } + + if (msg_params.keyExists(strings::vr_help)) { + const smart_objects::SmartArray* vh_array = + msg_params[strings::vr_help].asArray(); + + smart_objects::SmartArray::const_iterator it_vh = vh_array->begin(); + smart_objects::SmartArray::const_iterator it_vh_end = vh_array->end(); + + for (; it_vh != it_vh_end; ++it_vh) { + str = (*it_vh)[strings::text].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_help text syntax check failed"); + return true; + } + + if ((*it_vh).keyExists(strings::image)) { + str = (*it_vh)[strings::image][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid vr_help image value syntax check failed"); + return true; + } + } + + } + } + + if (msg_params.keyExists(strings::menu_icon)) { + str = msg_params[strings::menu_icon][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid menu_icon value syntax check failed"); + return true; + } + } + + if (msg_params.keyExists(strings::vr_help_title)) { + str = msg_params[strings::vr_help_title].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid vr_help_title value syntax check failed"); + return true; + } + } + + if (msg_params.keyExists(strings::menu_title)) { + str = msg_params[strings::menu_title].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid menu_title value syntax check failed"); + return true; + } + } + + + if (msg_params.keyExists(strings::keyboard_properties)) { + if (msg_params[strings::keyboard_properties]. + keyExists(strings::limited_character_list)) { + + const smart_objects::SmartArray* lcl_array = + msg_params[strings::keyboard_properties] + [strings::limited_character_list].asArray(); + + smart_objects::SmartArray::const_iterator it_lcl = lcl_array->begin(); + smart_objects::SmartArray::const_iterator it_lcl_end = lcl_array->end(); + + for (; it_lcl != it_lcl_end; ++it_lcl) { + str = (*it_lcl).asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid keyboard_properties " + "limited_character_list syntax check failed"); + return true; + } + } + } + + if (msg_params[strings::keyboard_properties]. + keyExists(strings::auto_complete_text)) { + + str = msg_params[strings::keyboard_properties] + [strings::auto_complete_text].asCharArray(); + + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid keyboard_properties " + "auto_complete_text syntax check failed"); + return true; + } + } + + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_global_properties_response.cc b/src/components/application_manager/src/commands/mobile/set_global_properties_response.cc new file mode 100644 index 0000000000..5f0b62fb4d --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_global_properties_response.cc @@ -0,0 +1,58 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_global_properties_response.h" +#include "application_manager/application_manager_impl.h" + + +namespace application_manager { + +namespace commands { + +SetGlobalPropertiesResponse::SetGlobalPropertiesResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SetGlobalPropertiesResponse::~SetGlobalPropertiesResponse() { +} + +void SetGlobalPropertiesResponse::Run() { + LOG4CXX_INFO(logger_, "SetGlobalPropertiesResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_icon_request.cc b/src/components/application_manager/src/commands/mobile/set_icon_request.cc new file mode 100644 index 0000000000..4b78833057 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_icon_request.cc @@ -0,0 +1,141 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_icon_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "config_profile/profile.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +SetIconRequest::SetIconRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SetIconRequest::~SetIconRequest() { +} + +void SetIconRequest::Run() { + LOG4CXX_INFO(logger_, "SetIconRequest::Run"); + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + const std::string& sync_file_name = + (*message_)[strings::msg_params][strings::sync_file_name].asString(); + + std::string full_file_path = + profile::Profile::instance()->app_storage_folder() + "/"; + full_file_path += app->folder_name(); + full_file_path += "/"; + full_file_path += sync_file_name; + + if (!file_system::FileExists(full_file_path)) { + LOG4CXX_ERROR(logger_, "No such file " << full_file_path); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::app_id] = app->app_id(); + msg_params[strings::sync_file_name] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + +// Requires unchanged path value without encoded special characters + const std::string full_file_path_for_hmi = file_system::ConvertPathForURL( + full_file_path); + + msg_params[strings::sync_file_name][strings::value] = full_file_path_for_hmi; + + // TODO(VS): research why is image_type hardcoded + msg_params[strings::sync_file_name][strings::image_type] = + static_cast<int32_t> (SetIconRequest::ImageType::DYNAMIC); + + // for further use in on_event function + (*message_)[strings::msg_params][strings::sync_file_name] = + msg_params[strings::sync_file_name]; + + SendHMIRequest(hmi_apis::FunctionID::UI_SetAppIcon, &msg_params, true); +} + +void SetIconRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SetIconRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_SetAppIcon: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + if (result) { + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + + const std::string path = (*message_)[strings::msg_params] + [strings::sync_file_name] + [strings::value].asString(); + app->set_app_icon_path(path); + + LOG4CXX_INFO(logger_, + "Icon path was set to '" << app->app_icon_path() << "'"); + } + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_icon_response.cc b/src/components/application_manager/src/commands/mobile/set_icon_response.cc new file mode 100644 index 0000000000..f1580823d1 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_icon_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_icon_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SetIconResponse::SetIconResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SetIconResponse::~SetIconResponse() { +} + +void SetIconResponse::Run() { + LOG4CXX_INFO(logger_, "SetIconResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_media_clock_timer_request.cc b/src/components/application_manager/src/commands/mobile/set_media_clock_timer_request.cc new file mode 100644 index 0000000000..c9b2eb5ef5 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_media_clock_timer_request.cc @@ -0,0 +1,152 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_media_clock_timer_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +SetMediaClockRequest::SetMediaClockRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SetMediaClockRequest::~SetMediaClockRequest() { +} + +void SetMediaClockRequest::Run() { + LOG4CXX_INFO(logger_, "SetMediaClockRequest::Run"); + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!app) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + if (!app->is_media_application()) { + LOG4CXX_ERROR(logger_, "Application is not media application"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + if (isDataValid()) { + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + // copy entirely msg + msg_params = (*message_)[strings::msg_params]; + msg_params[strings::app_id] = app->app_id(); + + SendHMIRequest(hmi_apis::FunctionID::UI_SetMediaClockTimer, + &msg_params, true); + } else { + SendResponse(false, mobile_apis::Result::INVALID_DATA); + } +} + +void SetMediaClockRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SetMediaClockRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_SetMediaClockTimer: { + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = mobile_apis::Result::SUCCESS == result_code; + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +bool SetMediaClockRequest::isDataValid() { + smart_objects::SmartObject msg_params = (*message_)[strings::msg_params]; + mobile_apis::UpdateMode::eType update_mode = + static_cast<mobile_apis::UpdateMode::eType>( + msg_params[strings::update_mode].asUInt()); + + if (update_mode == mobile_apis::UpdateMode::COUNTUP || + update_mode == mobile_apis::UpdateMode::COUNTDOWN) { + + if (!msg_params.keyExists(strings::start_time)) { + LOG4CXX_INFO(logger_, "Invalid data"); + return false; + } + + if (msg_params.keyExists(strings::end_time)) { + unsigned int start_time_in_seconds = 0; + start_time_in_seconds = + (msg_params[strings::start_time][strings::hours].asUInt()) * 3600; + start_time_in_seconds += + (msg_params[strings::start_time][strings::minutes].asUInt()) * 60; + start_time_in_seconds += + (msg_params[strings::start_time][strings::seconds].asUInt()); + + unsigned int end_time_in_seconds = 0; + end_time_in_seconds = + (msg_params[strings::end_time][strings::hours].asUInt()) * 3600; + end_time_in_seconds += + (msg_params[strings::end_time][strings::minutes].asUInt()) * 60; + end_time_in_seconds += + (msg_params[strings::end_time][strings::seconds].asUInt()); + + if (((end_time_in_seconds > start_time_in_seconds) && + (update_mode == mobile_apis::UpdateMode::COUNTDOWN)) || + ((end_time_in_seconds < start_time_in_seconds) && + (update_mode == mobile_apis::UpdateMode::COUNTUP))) { + LOG4CXX_INFO(logger_, "Invalid data"); + return false; + } + } + } + + LOG4CXX_INFO(logger_, "Data is valid"); + return true; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/set_media_clock_timer_response.cc b/src/components/application_manager/src/commands/mobile/set_media_clock_timer_response.cc new file mode 100644 index 0000000000..73923b0021 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/set_media_clock_timer_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/set_media_clock_timer_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SetMediaClockTimerResponse::SetMediaClockTimerResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SetMediaClockTimerResponse::~SetMediaClockTimerResponse() { +} + +void SetMediaClockTimerResponse::Run() { + LOG4CXX_INFO(logger_, "SetMediaClockTimerResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc b/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc new file mode 100644 index 0000000000..f4e70c53ac --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/show_constant_tbt_request.cc @@ -0,0 +1,283 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include "application_manager/commands/mobile/show_constant_tbt_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ShowConstantTBTRequest::ShowConstantTBTRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +ShowConstantTBTRequest::~ShowConstantTBTRequest() { +} + +void ShowConstantTBTRequest::Run() { + LOG4CXX_INFO(logger_, "ShowConstantTBTRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + // SDLAQ-CRS-664, VC3.1 + if ((*message_)[strings::msg_params].empty()) { + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params = (*message_)[strings::msg_params]; + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming show constant TBT has contains \t\n \\t \\n"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + //ProcessSoftButtons checks strings on the contents incorrect character + + mobile_apis::Result::eType processing_result = + MessageHelper::ProcessSoftButtons(msg_params, app); + + if (mobile_apis::Result::SUCCESS != processing_result) { + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, processing_result); + return; + } + + + mobile_apis::Result::eType verification_result = + mobile_apis::Result::SUCCESS; + if (msg_params.keyExists(strings::turn_icon)) { + verification_result = MessageHelper::VerifyImage( + msg_params[strings::turn_icon], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!"); + SendResponse(false, verification_result); + return; + } + } + + if (msg_params.keyExists(strings::next_turn_icon)) { + verification_result = MessageHelper::VerifyImage( + msg_params[strings::next_turn_icon], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!"); + SendResponse(false, verification_result); + return; + } + } + + msg_params[strings::app_id] = app->app_id(); + + msg_params[hmi_request::navi_texts] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + + int32_t index = 0; + if (msg_params.keyExists(strings::navigation_text_1)) { + // erase useless parametr + msg_params.erase(strings::navigation_text_1); + msg_params[hmi_request::navi_texts][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::navigationText1); + msg_params[hmi_request::navi_texts][index++][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::navigation_text_1]; + } + + if (msg_params.keyExists(strings::navigation_text_2)) { + // erase useless param + msg_params.erase(strings::navigation_text_2); + msg_params[hmi_request::navi_texts][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::navigationText2); + msg_params[hmi_request::navi_texts][index++][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::navigation_text_2]; + } + + if (msg_params.keyExists(strings::eta)) { + // erase useless param + msg_params.erase(strings::eta); + msg_params[hmi_request::navi_texts][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::ETA); + msg_params[hmi_request::navi_texts][index++][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::eta]; + } + + if (msg_params.keyExists(strings::total_distance)) { + // erase useless param + msg_params.erase(strings::total_distance); + msg_params[hmi_request::navi_texts][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::totalDistance); + msg_params[hmi_request::navi_texts][index++][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::total_distance]; + } + + if (msg_params.keyExists(strings::time_to_destination)) { + // erase useless param + msg_params.erase(strings::time_to_destination); + msg_params[hmi_request::navi_texts][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::timeToDestination); + msg_params[hmi_request::navi_texts][index++][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::time_to_destination]; + } + + if (msg_params.keyExists(strings::soft_buttons)) { + MessageHelper::SubscribeApplicationToSoftButton(msg_params, app, function_id()); + } + + app->set_tbt_show_command(msg_params); + SendHMIRequest(hmi_apis::FunctionID::Navigation_ShowConstantTBT, &msg_params, + true); +} + + +void ShowConstantTBTRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ShowConstantTBTRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::Navigation_ShowConstantTBT: { + LOG4CXX_INFO(logger_, "Received Navigation_ShowConstantTBT event"); + + mobile_apis::Result::eType result_code = + GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt())); + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + bool result = false; + if (mobile_apis::Result::SUCCESS == result_code) { + result = true; + } else if ((mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code) && + hmi_capabilities.is_ui_cooperating()) { + result = true; + } + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + break; + } + } +} + +bool ShowConstantTBTRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "ShowConstantTBTRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::turn_icon)) { + str = (*message_)[strings::msg_params] + [strings::turn_icon][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid turn_icon value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::next_turn_icon)) { + str = (*message_)[strings::msg_params] + [strings::next_turn_icon][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid next_turn_icon value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::navigation_text_1)) { + str = (*message_)[strings::msg_params] + [strings::navigation_text_1].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid navigation_text_1 value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::navigation_text_2)) { + str = (*message_)[strings::msg_params] + [strings::navigation_text_2].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid navigation_text_2 value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::eta)) { + str = (*message_)[strings::msg_params][strings::eta].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid eta value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::total_distance)) { + str = (*message_)[strings::msg_params] + [strings::total_distance].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid total_distance value syntax check failed"); + return true; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::time_to_destination)) { + str = (*message_)[strings::msg_params] + [strings::time_to_destination].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid time_to_destination value syntax check failed"); + return true; + } + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/show_constant_tbt_response.cc b/src/components/application_manager/src/commands/mobile/show_constant_tbt_response.cc new file mode 100644 index 0000000000..d5539d148c --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/show_constant_tbt_response.cc @@ -0,0 +1,58 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/show_constant_tbt_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ShowConstantTBTResponse::ShowConstantTBTResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +ShowConstantTBTResponse::~ShowConstantTBTResponse() { +} + +void ShowConstantTBTResponse::Run() { + LOG4CXX_INFO(logger_, "ShowConstantTBTResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/show_request.cc b/src/components/application_manager/src/commands/mobile/show_request.cc new file mode 100644 index 0000000000..eeef60101e --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/show_request.cc @@ -0,0 +1,341 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/show_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application.h" +#include "application_manager/message_helper.h" +#include "utils/file_system.h" + +#include <string.h> + +namespace application_manager { + +namespace commands { + +ShowRequest::ShowRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +ShowRequest::~ShowRequest() { +} + +void ShowRequest::Run() { + LOG4CXX_INFO(logger_, "ShowRequest::Run"); + + ApplicationSharedPtr app = application_manager::ApplicationManagerImpl::instance() + ->application( + (*message_)[strings::params][strings::connection_key].asInt()); + + if (!app) { + LOG4CXX_ERROR_EXT( + logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + //SDLAQ-CRS-494, VC3.1 + if ((*message_)[strings::msg_params].empty()) { + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if (!CheckStringsOfShowRequest()) { + LOG4CXX_ERROR(logger_, "Incorrect characters in string"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + //ProcessSoftButtons checks strings on the contents incorrect character + + mobile_apis::Result::eType processing_result = mobile_apis::Result::SUCCESS; + if(((*message_)[strings::msg_params].keyExists(strings::soft_buttons)) && + ((*message_)[strings::msg_params][strings::soft_buttons].length() > 0)) { + processing_result = + MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app); + } + + if (mobile_apis::Result::SUCCESS != processing_result) { + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, processing_result); + return; + } + + mobile_apis::Result::eType verification_result = + mobile_apis::Result::SUCCESS; + if (((*message_)[strings::msg_params].keyExists(strings::graphic)) && + ((*message_)[strings::msg_params] + [strings::graphic][strings::value].asString()).length()) { + verification_result = MessageHelper::VerifyImage( + (*message_)[strings::msg_params][strings::graphic], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!"); + SendResponse(false, verification_result); + return; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::secondary_graphic)) { + verification_result = MessageHelper::VerifyImage( + (*message_)[strings::msg_params][strings::secondary_graphic], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + LOG4CXX_ERROR(logger_, "VerifyImage INVALID_DATA!"); + SendResponse(false, verification_result); + return; + } + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app->app_id(); + + msg_params[hmi_request::show_strings] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + + int32_t index = 0; + if ((*message_)[strings::msg_params].keyExists(strings::main_field_1)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::mainField1); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::main_field_1]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::main_field_2)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::mainField2); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::main_field_2]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::main_field_3)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::mainField3); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::main_field_3]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::main_field_4)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::mainField4); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::main_field_4]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::media_clock)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::mediaClock); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::media_clock]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::media_track)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::mediaTrack); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::media_track]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::status_bar)) { + msg_params[hmi_request::show_strings][index][hmi_request::field_name] = + static_cast<int32_t>(hmi_apis::Common_TextFieldName::statusBar); + msg_params[hmi_request::show_strings][index][hmi_request::field_text] = + (*message_)[strings::msg_params][strings::status_bar]; + ++index; + } + + if ((*message_)[strings::msg_params].keyExists(strings::alignment)) { + msg_params[strings::alignment] = + (*message_)[strings::msg_params][strings::alignment]; + } + + if ((*message_)[strings::msg_params].keyExists(strings::graphic)) { + msg_params[strings::graphic] = + (*message_)[strings::msg_params][strings::graphic]; + } + + if ((*message_)[strings::msg_params].keyExists(strings::secondary_graphic)) { + msg_params[strings::secondary_graphic] = + (*message_)[strings::msg_params][strings::secondary_graphic]; + } + + if ((*message_)[strings::msg_params].keyExists(strings::soft_buttons)) { + msg_params[strings::soft_buttons] = + (*message_)[strings::msg_params][strings::soft_buttons]; + if ((*message_)[strings::msg_params][strings::soft_buttons].length() == 0) { + app->UnsubscribeFromSoftButtons(function_id()); + } else { + MessageHelper::SubscribeApplicationToSoftButton( + (*message_)[strings::msg_params], app, function_id()); + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::custom_presets)) { + msg_params[strings::custom_presets] = + (*message_)[strings::msg_params][strings::custom_presets]; + } + + SendHMIRequest(hmi_apis::FunctionID::UI_Show, &msg_params, true); + + MessageSharedPtr persistentData = new smart_objects::SmartObject(msg_params); + app->set_show_command(*persistentData); +} + +void ShowRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ShowRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::UI_Show: { + LOG4CXX_INFO(logger_, "Received UI_Show event"); + std::string response_info(""); + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = false; + + if (mobile_apis::Result::SUCCESS == result_code) { + result = true; + } else if (mobile_apis::Result::WARNINGS == result_code) { + result = true; + if (message[strings::params].keyExists(hmi_response::message)) { + response_info = message[strings::params][hmi_response::message].asString(); + } + } + + SendResponse(result, result_code, + response_info.empty() ? NULL : response_info.c_str(), + &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + break; + } + } +} + +bool ShowRequest::CheckStringsOfShowRequest() { + LOG4CXX_INFO(logger_, "ShowRequest::CheckStringsOfShowRequest"); + const char* str; + + if ((*message_)[strings::msg_params].keyExists(strings::main_field_4)) { + str = (*message_)[strings::msg_params][strings::main_field_4].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid main_field_4 syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::main_field_3)) { + str = (*message_)[strings::msg_params][strings::main_field_3].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid main_field_3 syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::main_field_2)) { + str = (*message_)[strings::msg_params][strings::main_field_2].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid main_field_2 syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::main_field_1)) { + str = (*message_)[strings::msg_params][strings::main_field_1].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid main_field_1 syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::status_bar)) { + str = (*message_)[strings::msg_params][strings::status_bar].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid status_bar syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::media_clock)) { + str = (*message_)[strings::msg_params][strings::media_clock].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid media_clock syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::media_track)) { + str = (*message_)[strings::msg_params][strings::media_track].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid media_track syntax check failed"); + return false; + } + } + if ((*message_)[strings::msg_params].keyExists(strings::custom_presets)) { + smart_objects::SmartObject& custom_presets_array = + (*message_)[strings::msg_params][strings::custom_presets]; + for (size_t i = 0; i < custom_presets_array.length(); ++i) { + str = custom_presets_array[i].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid custom_presets syntax check failed"); + return false; + } + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::graphic)) { + str = (*message_)[strings::msg_params] + [strings::graphic][strings::value].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid graphic value syntax check failed"); + return false; + } + } + + if ((*message_)[strings::msg_params].keyExists(strings::secondary_graphic)) { + str = (*message_)[strings::msg_params] + [strings::secondary_graphic][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid secondary_graphic value syntax check failed"); + return false; + } + } + return true; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/show_response.cc b/src/components/application_manager/src/commands/mobile/show_response.cc new file mode 100644 index 0000000000..1f9c59c6fc --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/show_response.cc @@ -0,0 +1,58 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/show_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +ShowResponse::ShowResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +ShowResponse::~ShowResponse() { +} + +void ShowResponse::Run() { + LOG4CXX_INFO(logger_, "ShowResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/slider_request.cc b/src/components/application_manager/src/commands/mobile/slider_request.cc new file mode 100644 index 0000000000..bf200d72d3 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/slider_request.cc @@ -0,0 +1,185 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/slider_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +SliderRequest::SliderRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { + subscribe_on_event(hmi_apis::FunctionID::UI_OnResetTimeout); +} + +SliderRequest::~SliderRequest() { +} + +bool SliderRequest::Init() { + + /* Timeout in milliseconds. + If omitted a standard value of 10000 milliseconds is used.*/ + if ((*message_)[strings::msg_params].keyExists(strings::timeout)) { + default_timeout_ = + (*message_)[strings::msg_params][strings::timeout].asUInt(); + } + + return true; +} + +void SliderRequest::Run() { + LOG4CXX_INFO(logger_, "SliderRequest::Run"); + + ApplicationSharedPtr application = + application_manager::ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!application) { + LOG4CXX_ERROR(logger_, "Application is not registered"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if ((*message_)[strings::msg_params][strings::num_ticks].asInt() + < (*message_)[strings::msg_params][strings::position].asInt()) { + LOG4CXX_ERROR(logger_, "INVALID_DATA"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + if ((*message_)[strings::msg_params].keyExists(strings::slider_footer)) { + if (1 < (*message_)[strings::msg_params][strings::slider_footer].length()) { + if ((*message_)[strings::msg_params][strings::num_ticks].asUInt() + != (*message_)[strings::msg_params] + [strings::slider_footer].length()) { + LOG4CXX_ERROR(logger_, "INVALID_DATA"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + } + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, "Incoming slider has contains \t\n \\t \\n"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params = (*message_)[strings::msg_params]; + msg_params[strings::app_id] = application->app_id(); + + if (!(*message_)[strings::msg_params].keyExists(strings::timeout)) { + msg_params[strings::timeout] = default_timeout_; + } + + SendHMIRequest(hmi_apis::FunctionID::UI_Slider, &msg_params, true); +} + +void SliderRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SliderRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + const event_engine::Event::EventID event_id = event.id(); + if (event_id == hmi_apis::FunctionID::UI_OnResetTimeout) { + LOG4CXX_INFO(logger_, "Received UI_OnResetTimeout event"); + ApplicationManagerImpl::instance()->updateRequestTimeout(connection_key(), + correlation_id(), + default_timeout()); + return; + } + if (event_id != hmi_apis::FunctionID::UI_Slider) { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + + //event_id == hmi_apis::FunctionID::UI_Slider: + LOG4CXX_INFO(logger_, "Received UI_Slider event"); + + const int response_code = + message[strings::params][hmi_response::code].asInt(); + + smart_objects::SmartObject response_msg_params = message[strings::msg_params]; + if (response_code == hmi_apis::Common_Result::ABORTED) { + //Copy slider_position info to msg_params section + response_msg_params[strings::slider_position] = + message[strings::params][strings::data][strings::slider_position]; + } + + const bool is_response_success = + (mobile_apis::Result::SUCCESS == response_code) || + //Aborted has slider_position data + (mobile_apis::Result::ABORTED == response_code) || + //according with SDLAQ-CRS-2904 + (mobile_apis::Result::TIMED_OUT == response_code); + + SendResponse(is_response_success, + mobile_apis::Result::eType(response_code), + 0, + &response_msg_params); +} + +bool SliderRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "PerformAudioPassThruRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + str = (*message_)[strings::msg_params][strings::slider_header].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid slider_header value syntax check failed"); + return true; + } + + if ((*message_)[strings::msg_params].keyExists(strings::slider_footer)) { + const smart_objects::SmartArray* sf_array = + (*message_)[strings::msg_params][strings::slider_footer].asArray(); + + smart_objects::SmartArray::const_iterator it_sf = sf_array->begin(); + smart_objects::SmartArray::const_iterator it_sf_end = sf_array->end(); + + for (; it_sf != it_sf_end; ++it_sf) { + str = (*it_sf).asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid slider_footer syntax check failed"); + return true; + } + } + } + return false; +} + +} // namespace commands +} // namespace application_manager + diff --git a/src/components/application_manager/src/commands/mobile/slider_response.cc b/src/components/application_manager/src/commands/mobile/slider_response.cc new file mode 100644 index 0000000000..bfb6b0a1e6 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/slider_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/slider_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SliderResponse::SliderResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SliderResponse::~SliderResponse() { +} + +void SliderResponse::Run() { + LOG4CXX_INFO(logger_, "SliderResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/speak_request.cc b/src/components/application_manager/src/commands/mobile/speak_request.cc new file mode 100644 index 0000000000..de37e8b49e --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/speak_request.cc @@ -0,0 +1,160 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string.h> +#include "application_manager/commands/mobile/speak_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +SpeakRequest::SpeakRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { + subscribe_on_event(hmi_apis::FunctionID::TTS_OnResetTimeout); +} + +SpeakRequest::~SpeakRequest() { +} + +void SpeakRequest::Run() { + LOG4CXX_INFO(logger_, "SpeakRequest::Run"); + + ApplicationSharedPtr app = application_manager::ApplicationManagerImpl::instance() + ->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming speak has contains \\t\\n \\\\t \\\\n " + " text contains only whitespace in ttsChunks"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + (*message_)[strings::msg_params][strings::app_id] = app->app_id(); + (*message_)[strings::msg_params][hmi_request::speak_type] = + hmi_apis::Common_SpeakType::SPEAK; + SendHMIRequest(hmi_apis::FunctionID::TTS_Speak, + &message_->getElement(strings::msg_params), true); +} + +void SpeakRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SpeakRequest::on_event"); + switch (event.id()) { + case hmi_apis::FunctionID::TTS_Speak: { + LOG4CXX_INFO(logger_, "Received TTS_Speak event"); + + ProcessTTSSpeakResponse(event.smart_object()); + break; + } + case hmi_apis::FunctionID::TTS_OnResetTimeout: { + LOG4CXX_INFO(logger_, "Received TTS_OnResetTimeout event"); + + ApplicationManagerImpl::instance()->updateRequestTimeout( + connection_key(), correlation_id(), default_timeout()); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + break; + } + } +} + +void SpeakRequest::ProcessTTSSpeakResponse( + const smart_objects::SmartObject& message) { + LOG4CXX_INFO(logger_, "SpeakRequest::ProcessTTSSpeakResponse"); + ApplicationSharedPtr application = ApplicationManagerImpl::instance()->application( + connection_key()); + + if (!application) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + bool result = false; + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + if (hmi_apis::Common_Result::SUCCESS == + static_cast<hmi_apis::Common_Result::eType>(result_code)) { + result = true; + } + (*message_)[strings::params][strings::function_id] = + mobile_apis::FunctionID::SpeakID; + + const char* return_info = NULL; + + if (hmi_apis::Common_Result::UNSUPPORTED_RESOURCE == + static_cast<hmi_apis::Common_Result::eType>(result_code)) { + result_code = mobile_apis::Result::WARNINGS; + return_info = std::string( + "Unsupported phoneme type sent in a prompt").c_str(); + } + + SendResponse(result, static_cast<mobile_apis::Result::eType>(result_code), + return_info, &(message[strings::msg_params])); +} + +bool SpeakRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "SpeakRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::tts_chunks)) { + const smart_objects::SmartArray* tc_array = + (*message_)[strings::msg_params][strings::tts_chunks].asArray(); + + smart_objects::SmartArray::const_iterator it_tc = tc_array->begin(); + smart_objects::SmartArray::const_iterator it_tc_end = tc_array->end(); + + for (; it_tc != it_tc_end; ++it_tc) { + str = (*it_tc)[strings::text].asCharArray(); + if (strlen(str) && !CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, "Invalid tts_chunks syntax check failed"); + return true; + } + } + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/speak_response.cc b/src/components/application_manager/src/commands/mobile/speak_response.cc new file mode 100644 index 0000000000..92b85bbb84 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/speak_response.cc @@ -0,0 +1,58 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/speak_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +SpeakResponse::SpeakResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SpeakResponse::~SpeakResponse() { +} + +void SpeakResponse::Run() { + LOG4CXX_INFO(logger_, "SpeakResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/subscribe_button_request.cc b/src/components/application_manager/src/commands/mobile/subscribe_button_request.cc new file mode 100644 index 0000000000..b6a4d8a28e --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/subscribe_button_request.cc @@ -0,0 +1,101 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/subscribe_button_request.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +namespace str = strings; + +SubscribeButtonRequest::SubscribeButtonRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SubscribeButtonRequest::~SubscribeButtonRequest() { +} + +void SubscribeButtonRequest::Run() { + LOG4CXX_INFO(logger_, "SubscribeButtonRequest::Run"); + + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "APPLICATION_NOT_REGISTERED"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + const mobile_apis::ButtonName::eType btn_id = + static_cast<mobile_apis::ButtonName::eType>( + (*message_)[str::msg_params][str::button_name].asUInt()); + + if (!IsSubscribtionAllowed(app, btn_id)) { + LOG4CXX_ERROR_EXT(logger_, "Subscribe on button " << btn_id + << " isn't allowed"); + SendResponse(false, mobile_apis::Result::REJECTED); + return; + } + + if (app->IsSubscribedToButton(btn_id)) { + LOG4CXX_ERROR_EXT(logger_, "Already subscribed to button " << btn_id); + SendResponse(false, mobile_apis::Result::IGNORED); + return; + } + + app->SubscribeToButton(static_cast<mobile_apis::ButtonName::eType>(btn_id)); + SendResponse(true, mobile_apis::Result::SUCCESS); + + app->UpdateHash(); +} + +bool SubscribeButtonRequest::IsSubscribtionAllowed( + ApplicationSharedPtr app, mobile_apis::ButtonName::eType btn_id) { + + if (!app->is_media_application() && + ((mobile_apis::ButtonName::SEEKLEFT == btn_id) || + (mobile_apis::ButtonName::SEEKRIGHT == btn_id)|| + (mobile_apis::ButtonName::TUNEUP == btn_id) || + (mobile_apis::ButtonName::TUNEDOWN == btn_id))) { + return false; + } + + return true; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/subscribe_button_response.cc b/src/components/application_manager/src/commands/mobile/subscribe_button_response.cc new file mode 100644 index 0000000000..6253f8ca3d --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/subscribe_button_response.cc @@ -0,0 +1,66 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/subscribe_button_response.h" + +namespace application_manager { + +namespace commands { + +SubscribeButtonResponse::SubscribeButtonResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SubscribeButtonResponse::~SubscribeButtonResponse() { +} + +void SubscribeButtonResponse::Run() { + LOG4CXX_INFO(logger_, "SubscribeButtonResponse::Run"); + + // check if response false + if (true == (*message_)[strings::msg_params].keyExists(strings::success)) { + if ((*message_)[strings::msg_params][strings::success].asBool() == false) { + LOG4CXX_ERROR(logger_, "Success = false"); + SendResponse(false); + return; + } + } + + // TODO(DK): Some logic + SendResponse(true); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/subscribe_vehicle_data_request.cc b/src/components/application_manager/src/commands/mobile/subscribe_vehicle_data_request.cc new file mode 100644 index 0000000000..35595c2df6 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/subscribe_vehicle_data_request.cc @@ -0,0 +1,283 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/subscribe_vehicle_data_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { +namespace commands { + +SubscribeVehicleDataRequest::SubscribeVehicleDataRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SubscribeVehicleDataRequest::~SubscribeVehicleDataRequest() { +} + +#ifdef HMI_DBUS_API +namespace { + struct Subrequest { + hmi_apis::FunctionID::eType func_id; + const char* str; + }; + Subrequest subrequests[] = { + { hmi_apis::FunctionID::VehicleInfo_SubscribeGps, strings::gps}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeSpeed, strings::speed}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeRpm, strings::rpm}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel, strings::fuel_level}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel_State, strings::fuel_level_state}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeInstantFuelConsumption, strings::instant_fuel_consumption}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeExternalTemperature, strings::external_temp}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeVin, strings::vin}, + { hmi_apis::FunctionID::VehicleInfo_SubscribePrndl, strings::prndl}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeTirePressure, strings::tire_pressure}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeOdometer, strings::odometer}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeBeltStatus, strings::belt_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeBodyInformation, strings::body_information}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeDeviceStatus, strings::device_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeDriverBraking, strings::driver_braking}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeWiperStatus, strings::wiper_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeHeadLampStatus, strings::head_lamp_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeEngineTorque, strings::engine_torque}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeAccPedalPosition, strings::acc_pedal_pos}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeSteeringWheelAngle, strings::steering_wheel_angle}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeECallInfo, strings::e_call_info}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeAirbagStatus, strings::airbag_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeEmergencyEvent, strings::emergency_event}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeClusterModeStatus, strings::cluster_mode_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeMyKey, strings::my_key}, + }; +} +#endif // #ifdef HMI_DBUS_API + +void SubscribeVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "SubscribeVehicleDataRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + CommandRequestImpl::connection_key()); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + // counter for items to subscribe + int32_t items_to_subscribe = 0; + // counter for subscribed items by application + int32_t subscribed_items = 0; + + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject response_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::app_id] = app->app_id(); + + for (; vehicle_data.end() != it; ++it) { + std::string key_name = it->first; + if ((*message_)[strings::msg_params].keyExists(key_name)) { + bool is_key_enabled = (*message_)[strings::msg_params][key_name].asBool(); + if (is_key_enabled) { + ++items_to_subscribe; + msg_params[key_name] = is_key_enabled; + + VehicleDataType key_type = it->second; + if (app->SubscribeToIVI(static_cast<uint32_t>(key_type))) { + ++subscribed_items; + } else { + response_params[key_name][strings::data_type] = key_type; + response_params[key_name][strings::result_code] = + mobile_apis::VehicleDataResultCode::VDRC_DATA_ALREADY_SUBSCRIBED; + } + } + } + } + + if (0 == items_to_subscribe) { + if (HasDisallowedParams()) { + SendResponse(false, mobile_apis::Result::DISALLOWED); + } else { + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "No data in the request"); + } + return; + } else if (0 == subscribed_items) { + SendResponse(false, + mobile_apis::Result::IGNORED, + "Already subscribed on provided VehicleData.", + &response_params); + return; + } + +#ifdef HMI_DBUS_API + //Generate list of subrequests + for (size_t i = 0; i < sizeof(subrequests) / sizeof(subrequests[0]); ++i) { + const Subrequest& sr = subrequests[i]; + if (true == (*message_)[strings::msg_params].keyExists(sr.str) + && true == (*message_)[strings::msg_params][sr.str].asBool()) { + HmiRequest hmi_request; + hmi_request.str = sr.str; + hmi_request.func_id = sr.func_id; + hmi_request.complete = false; + hmi_requests_.push_back(hmi_request); + } + } + LOG4CXX_INFO(logger_, hmi_requests_.size() << " requests are going to be sent to HMI"); + + //Send subrequests + for (HmiRequests::const_iterator it = hmi_requests_.begin(); it != hmi_requests_.end(); ++it) + SendHMIRequest(it->func_id, &msg_params, true); +#else + SendHMIRequest(hmi_apis::FunctionID::VehicleInfo_SubscribeVehicleData, + &msg_params, true); +#endif // #ifdef HMI_DBUS_API +} + +void SubscribeVehicleDataRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "SubscribeVehicleDataRequest::on_event"); + + const smart_objects::SmartObject& message = event.smart_object(); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + CommandRequestImpl::connection_key()); + +#ifdef HMI_DBUS_API + for (HmiRequests::iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + HmiRequest & hmi_request = *it; + if (hmi_request.func_id == event.id()) { + hmi_request.status = + static_cast<hmi_apis::Common_Result::eType>(message[strings::params][hmi_response::code] + .asInt()); + if (hmi_apis::Common_Result::SUCCESS == hmi_request.status) + hmi_request.value = message[strings::msg_params][hmi_request.str]; + hmi_request.complete = true; + break; + } + } + bool all_complete = true; + bool any_arg_success = false; + mobile_api::Result::eType status = mobile_api::Result::eType::SUCCESS; + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + if (!it->complete) { + all_complete = false; + break; + } + if (hmi_apis::Common_Result::SUCCESS != it->status) { + if (mobile_api::Result::SUCCESS == status) { + status = static_cast<mobile_apis::Result::eType>(it->status); + } else if (status + != static_cast<mobile_apis::Result::eType>(it->status)) { + status = mobile_api::Result::eType::GENERIC_ERROR; + } + LOG4CXX_TRACE(logger_, "Status from HMI: " << it->status << + ", so response status become " << status); + } else { + any_arg_success = true; + } + } + + if (all_complete) { + smart_objects::SmartObject response_params(smart_objects::SmartType_Map); + if (any_arg_success) { + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + response_params[it->str] = it->value; + } + } + LOG4CXX_INFO(logger_, "All HMI requests are complete"); + SendResponse(any_arg_success, status, NULL, &response_params); + app->UpdateHash(); + } +#else + hmi_apis::Common_Result::eType hmi_result = + static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = + hmi_result == hmi_apis::Common_Result::SUCCESS; + + mobile_apis::Result::eType result_code = + hmi_result == hmi_apis::Common_Result::SUCCESS + ? mobile_apis::Result::SUCCESS + : static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + const char* return_info = NULL; + if (result) { + if (IsAnythingAlreadySubscribed(message[strings::msg_params])) { + result_code = mobile_apis::Result::IGNORED; + return_info = + std::string("Already subscribed on some provided VehicleData.").c_str(); + } + } + + SendResponse(result, + result_code, + return_info, + &(message[strings::msg_params])); + app->UpdateHash(); +#endif // #ifdef HMI_DBUS_API +} + +bool SubscribeVehicleDataRequest::IsAnythingAlreadySubscribed( + const smart_objects::SmartObject& msg_params) const { + LOG4CXX_INFO(logger_, "IsAnythingAlreadySubscribed"); + + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + + for (; vehicle_data.end() != it; ++it) { + if (msg_params.keyExists(it->first)) { + if (msg_params[it->first][strings::result_code].asInt() == + hmi_apis::Common_VehicleDataResultCode::VDRC_DATA_ALREADY_SUBSCRIBED) { + return true; + } + } + } + + return false; +} + + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/subscribe_vehicle_data_response.cc b/src/components/application_manager/src/commands/mobile/subscribe_vehicle_data_response.cc new file mode 100644 index 0000000000..972a654188 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/subscribe_vehicle_data_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/subscribe_vehicle_data_response.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { +namespace commands { + +SubscribeVehicleDataResponse::SubscribeVehicleDataResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SubscribeVehicleDataResponse::~SubscribeVehicleDataResponse() { +} + +void SubscribeVehicleDataResponse::Run() { + LOG4CXX_INFO(logger_, "SubscribeVehicleDataResponse::Run"); + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/system_request.cc b/src/components/application_manager/src/commands/mobile/system_request.cc new file mode 100644 index 0000000000..2765aad8d7 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/system_request.cc @@ -0,0 +1,168 @@ +/* + +Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <vector> +#include <string> +#include <stdio.h> +#include "application_manager/commands/mobile/system_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "interfaces/MOBILE_API.h" +#include "config_profile/profile.h" +#include "utils/file_system.h" + +namespace application_manager { + +namespace commands { + +uint32_t SystemRequest::index = 0; + +SystemRequest::SystemRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +SystemRequest::~SystemRequest() { +} + +void SystemRequest::Run() { + LOG4CXX_INFO(logger_, "SystemRequest::Run"); + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!(application.valid())) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + mobile_apis::RequestType::eType request_type = + static_cast<mobile_apis::RequestType::eType>( + (*message_)[strings::msg_params][strings::request_type].asInt()); + + if (!(*message_)[strings::params].keyExists(strings::binary_data) && + mobile_apis::RequestType::PROPRIETARY == request_type) { + LOG4CXX_ERROR(logger_, "Binary data empty"); + + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + std::vector<uint8_t> binary_data; + if ((*message_)[strings::params].keyExists(strings::binary_data)) { + binary_data = (*message_)[strings::params][strings::binary_data].asBinary(); + } + + std::string file_path = profile::Profile::instance()->system_files_path(); + if (!file_system::CreateDirectoryRecursively(file_path)) { + LOG4CXX_ERROR(logger_, "Cann't create folder."); + SendResponse(false, mobile_apis::Result::GENERIC_ERROR); + return; + } + + std::string file_name = "SYNC"; + if ((*message_)[strings::msg_params].keyExists(strings::file_name)) { + file_name = (*message_)[strings::msg_params][strings::file_name].asString(); + } + + // to avoid override existing file + const uint8_t max_size = 255; + char buf[max_size] = {'\0'}; + snprintf(buf, sizeof(buf)/sizeof(buf[0]), "%d%s", index++, file_name.c_str()); + file_name = buf; + + std::string full_file_path = file_path + "/" + file_name; + if (binary_data.size()) { + if (mobile_apis::Result::SUCCESS != + (ApplicationManagerImpl::instance()->SaveBinary( + binary_data, file_path, file_name, 0))) { + SendResponse(false, mobile_apis::Result::GENERIC_ERROR); + return; + } + } else { + if (!(file_system::CreateFile(full_file_path))) { + SendResponse(false, mobile_apis::Result::GENERIC_ERROR); + return; + } + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (std::string::npos != file_name.find("IVSU")) { + msg_params[strings::file_name] = file_name.c_str(); + } else { + msg_params[strings::file_name] = full_file_path; + } + + if (mobile_apis::RequestType::PROPRIETARY != request_type) { + msg_params[strings::app_id] = (application->mobile_app_id())->asString(); + } + msg_params[strings::request_type] = + (*message_)[strings::msg_params][strings::request_type]; + SendHMIRequest(hmi_apis::FunctionID::BasicCommunication_SystemRequest, + &msg_params, true); + +} + +void SystemRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "AddSubMenuRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::BasicCommunication_SystemRequest: { + mobile_apis::Result::eType result_code = + GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asUInt())); + bool result = mobile_apis::Result::SUCCESS == result_code; + + ApplicationSharedPtr application = + ApplicationManagerImpl::instance()->application(connection_key()); + + if (!(application.valid())) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + return; + } + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_, "Received unknown event" << event.id()); + return; + } + } +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/system_response.cc b/src/components/application_manager/src/commands/mobile/system_response.cc new file mode 100644 index 0000000000..e77ab08450 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/system_response.cc @@ -0,0 +1,56 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/system_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +SystemResponse::SystemResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +SystemResponse::~SystemResponse() { +} + +void SystemResponse::Run() { + LOG4CXX_INFO(logger_, "SystemResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/unregister_app_interface_request.cc b/src/components/application_manager/src/commands/mobile/unregister_app_interface_request.cc new file mode 100644 index 0000000000..a07cfcd8f0 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/unregister_app_interface_request.cc @@ -0,0 +1,60 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/unregister_app_interface_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" + +namespace application_manager { + +namespace commands { + +void UnregisterAppInterfaceRequest::Run() { + LOG4CXX_INFO(logger_, "UnregisterAppInterfaceRequest::Run"); + + ApplicationManagerImpl* app_manager = ApplicationManagerImpl::instance(); + + if (!app_manager->application(connection_key())) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + app_manager->UnregisterApplication(connection_key(), + mobile_apis::Result::SUCCESS); + SendResponse(true, mobile_apis::Result::SUCCESS); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/unregister_app_interface_response.cc b/src/components/application_manager/src/commands/mobile/unregister_app_interface_response.cc new file mode 100644 index 0000000000..8ef0eb3ed0 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/unregister_app_interface_response.cc @@ -0,0 +1,47 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/unregister_app_interface_response.h" + +namespace application_manager { + +namespace commands { + +void UnregisterAppInterfaceResponse::Run() { + LOG4CXX_INFO(logger_, "UnregisterAppInterfaceResponse::Run"); + + SendResponse((*message_)[strings::msg_params][strings::success].asBool()); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/unsubscribe_button_request.cc b/src/components/application_manager/src/commands/mobile/unsubscribe_button_request.cc new file mode 100644 index 0000000000..f22d1c0a2f --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/unsubscribe_button_request.cc @@ -0,0 +1,79 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/unsubscribe_button_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" + +namespace application_manager { + +namespace commands { + +namespace str = strings; + +UnsubscribeButtonRequest::UnsubscribeButtonRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +UnsubscribeButtonRequest::~UnsubscribeButtonRequest() { +} + +void UnsubscribeButtonRequest::Run() { + LOG4CXX_INFO(logger_, "UnsubscribeButtonRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[str::params][str::connection_key].asUInt()); + + if (!app) { + LOG4CXX_ERROR_EXT(logger_, "APPLICATION_NOT_REGISTERED"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + const uint32_t btn_id = (*message_)[str::msg_params][str::button_name] + .asUInt(); + + if (!app->IsSubscribedToButton(static_cast<mobile_apis::ButtonName::eType>(btn_id))) { + LOG4CXX_ERROR_EXT(logger_, "App doesn't subscibe to button " << btn_id); + SendResponse(false, mobile_apis::Result::IGNORED); + return; + } + + app->UnsubscribeFromButton(static_cast<mobile_apis::ButtonName::eType>(btn_id)); + SendResponse(true, mobile_apis::Result::SUCCESS); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/unsubscribe_button_response.cc b/src/components/application_manager/src/commands/mobile/unsubscribe_button_response.cc new file mode 100644 index 0000000000..1331eac27f --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/unsubscribe_button_response.cc @@ -0,0 +1,69 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/unsubscribe_button_response.h" +#include "application_manager/application_manager_impl.h" + +namespace application_manager { + +namespace commands { + +UnsubscribeButtonResponse::UnsubscribeButtonResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +UnsubscribeButtonResponse::~UnsubscribeButtonResponse() { +} + +void UnsubscribeButtonResponse::Run() { + LOG4CXX_INFO(logger_, "UnsubscribeButtonResponse::Run"); + + namespace smart_objects = NsSmartDeviceLink::NsSmartObjects; + + // check if response false + if (true == (*message_)[strings::msg_params].keyExists(strings::success)) { + if ((*message_)[strings::msg_params][strings::success].asBool() == false) { + LOG4CXX_ERROR(logger_, "Success = false"); + SendResponse(false); + return; + } + } + + // TODO(DK): Some logic + SendResponse(true); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/unsubscribe_vehicle_data_request.cc b/src/components/application_manager/src/commands/mobile/unsubscribe_vehicle_data_request.cc new file mode 100644 index 0000000000..fc7145078f --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/unsubscribe_vehicle_data_request.cc @@ -0,0 +1,279 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/unsubscribe_vehicle_data_request.h" +#include "application_manager/commands/command_impl.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" +#include "application_manager/smart_object_keys.h" + +namespace application_manager { +namespace commands { + +UnsubscribeVehicleDataRequest::UnsubscribeVehicleDataRequest( + const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +UnsubscribeVehicleDataRequest::~UnsubscribeVehicleDataRequest() { +} + +#ifdef HMI_DBUS_API +namespace { + struct Subrequest { + hmi_apis::FunctionID::eType func_id; + const char* str; + }; + Subrequest subrequests[] = { + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeGps, strings::gps}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeSpeed, strings::speed}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeRpm, strings::rpm}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel, strings::fuel_level}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel_State, strings::fuel_level_state}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeInstantFuelConsumption, strings::instant_fuel_consumption}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeExternalTemperature, strings::external_temp}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeVin, strings::vin}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribePrndl, strings::prndl}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeTirePressure, strings::tire_pressure}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeOdometer, strings::odometer}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeBeltStatus, strings::belt_status}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeBodyInformation, strings::body_information}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeDeviceStatus, strings::device_status}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeDriverBraking, strings::driver_braking}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeWiperStatus, strings::wiper_status}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeHeadLampStatus, strings::head_lamp_status}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeEngineTorque, strings::engine_torque}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeAccPedalPosition, strings::acc_pedal_pos}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeSteeringWheelAngle, strings::steering_wheel_angle}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeECallInfo, strings::e_call_info}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeAirbagStatus, strings::airbag_status}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeEmergencyEvent, strings::emergency_event}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeClusterModeStatus, strings::cluster_mode_status}, + { hmi_apis::FunctionID::VehicleInfo_UnsubscribeMyKey, strings::my_key}, + }; +} +#endif // #ifdef HMI_DBUS_API + +void UnsubscribeVehicleDataRequest::Run() { + LOG4CXX_INFO(logger_, "UnsubscribeVehicleDataRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + CommandRequestImpl::connection_key()); + + if (!app) { + LOG4CXX_ERROR(logger_, "NULL pointer"); + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + return; + } + + // counter for items to subscribe + int32_t items_to_unsubscribe = 0; + // counter for subscribed items by application + int32_t unsubscribed_items = 0; + + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject response_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::app_id] = app->app_id(); + + for (; vehicle_data.end() != it; ++it) { + std::string key_name = it->first; + if ((*message_)[strings::msg_params].keyExists(key_name)) { + bool is_key_enabled = (*message_)[strings::msg_params][key_name].asBool(); + if (is_key_enabled) { + ++items_to_unsubscribe; + msg_params[key_name] = is_key_enabled; + + VehicleDataType key_type = it->second; + if (app->UnsubscribeFromIVI(static_cast<uint32_t>(key_type))) { + ++unsubscribed_items; + } else { + response_params[key_name][strings::data_type] = key_type; + response_params[key_name][strings::result_code] = + mobile_apis::VehicleDataResultCode::VDRC_DATA_NOT_SUBSCRIBED; + } + } + } + } + + if (0 == items_to_unsubscribe) { + if (HasDisallowedParams()) { + SendResponse(false, mobile_apis::Result::DISALLOWED); + } else { + SendResponse(false, mobile_apis::Result::INVALID_DATA, + "No data in the request."); + } + return; + } else if (0 == unsubscribed_items) { + SendResponse(false, mobile_apis::Result::IGNORED, + "Was not subscribed on any VehicleData.", &response_params); + return; + } + +#ifdef HMI_DBUS_API + //Generate list of subrequests + for (size_t i = 0; i < sizeof(subrequests) / sizeof(subrequests[0]); ++i) { + const Subrequest& sr = subrequests[i]; + if (true == (*message_)[strings::msg_params].keyExists(sr.str) + && true == (*message_)[strings::msg_params][sr.str].asBool()) { + HmiRequest hmi_request; + hmi_request.str = sr.str; + hmi_request.func_id = sr.func_id; + hmi_request.complete = false; + hmi_requests_.push_back(hmi_request); + } + } + LOG4CXX_INFO(logger_, + hmi_requests_.size() << " requests are going to be sent to HMI"); + + //Send subrequests + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) + SendHMIRequest(it->func_id, &msg_params, true); +#else + SendHMIRequest(hmi_apis::FunctionID::VehicleInfo_UnsubscribeVehicleData, + &msg_params, true); +#endif // #ifdef HMI_DBUS_API +} + +void UnsubscribeVehicleDataRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "UnsubscribeVehicleDataRequest::on_event"); + + const smart_objects::SmartObject& message = event.smart_object(); + +#ifdef HMI_DBUS_API + for (HmiRequests::iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + HmiRequest & hmi_request = *it; + if (hmi_request.func_id == event.id()) { + hmi_request.status = + static_cast<hmi_apis::Common_Result::eType>(message[strings::params][hmi_response::code] + .asInt()); + if (hmi_apis::Common_Result::SUCCESS == hmi_request.status) + hmi_request.value = message[strings::msg_params][hmi_request.str]; + hmi_request.complete = true; + break; + } + } + bool all_complete = true; + bool any_arg_success = false; + mobile_api::Result::eType status = mobile_api::Result::eType::SUCCESS; + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + if (!it->complete) { + all_complete = false; + break; + } + if (hmi_apis::Common_Result::SUCCESS != it->status) { + if (mobile_api::Result::SUCCESS == status) { + status = static_cast<mobile_apis::Result::eType>(it->status); + } else if (status + != static_cast<mobile_apis::Result::eType>(it->status)) { + status = mobile_api::Result::eType::GENERIC_ERROR; + } LOG4CXX_TRACE(logger_, "Status from HMI: " << it->status << + ", so response status become " << status); + } else { + any_arg_success = true; + } + } + if (all_complete) { + smart_objects::SmartObject response_params(smart_objects::SmartType_Map); + if (any_arg_success) { + for (HmiRequests::const_iterator it = hmi_requests_.begin(); + it != hmi_requests_.end(); ++it) { + response_params[it->str] = it->value; + } + } + LOG4CXX_INFO(logger_, "All HMI requests are complete"); + SendResponse(any_arg_success, status, NULL, &response_params); + } +#else + hmi_apis::Common_Result::eType hmi_result = + static_cast<hmi_apis::Common_Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + bool result = + hmi_result == hmi_apis::Common_Result::SUCCESS; + + mobile_apis::Result::eType result_code = + hmi_result == hmi_apis::Common_Result::SUCCESS + ? mobile_apis::Result::SUCCESS + : static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + + const char* return_info = NULL; + + if (result) { + if (IsAnythingAlreadyUnsubscribed(message[strings::msg_params])) { + result_code = mobile_apis::Result::IGNORED; + return_info = + std::string("Some provided VehicleData was not subscribed.").c_str(); + } + } + + SendResponse(result, result_code, return_info, + &(message[strings::msg_params])); +#endif // #ifdef HMI_DBUS_API +} + +bool UnsubscribeVehicleDataRequest::IsAnythingAlreadyUnsubscribed( + const smart_objects::SmartObject& msg_params) const { + LOG4CXX_INFO(logger_, "IsAnythingAlreadyUnsubscribed"); + + const VehicleData& vehicle_data = MessageHelper::vehicle_data(); + VehicleData::const_iterator it = vehicle_data.begin(); + + for (; vehicle_data.end() != it; ++it) { + if (msg_params.keyExists(it->first)) { + if (msg_params[it->first][strings::result_code].asInt() == + hmi_apis::Common_VehicleDataResultCode::VDRC_DATA_NOT_SUBSCRIBED) { + return true; + } + } + } + + return false; +} + + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/unsubscribe_vehicle_data_response.cc b/src/components/application_manager/src/commands/mobile/unsubscribe_vehicle_data_response.cc new file mode 100644 index 0000000000..60f7077da7 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/unsubscribe_vehicle_data_response.cc @@ -0,0 +1,66 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/unsubscribe_vehicle_data_response.h" + +namespace application_manager { +namespace commands { + +UnsubscribeVehicleDataResponse::UnsubscribeVehicleDataResponse( + const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +UnsubscribeVehicleDataResponse::~UnsubscribeVehicleDataResponse() { +} + +void UnsubscribeVehicleDataResponse::Run() { + LOG4CXX_INFO(logger_, "UnsubscribeVehicleDataResponse::Run"); + + namespace smart_objects = NsSmartDeviceLink::NsSmartObjects; + + // check if response false + if (true == (*message_)[strings::msg_params].keyExists(strings::success)) { + if ((*message_)[strings::msg_params][strings::success].asBool() == false) { + LOG4CXX_ERROR(logger_, "Success = false"); + SendResponse(false); + return; + } + } + + // TODO(DK): Some logic + SendResponse(true); +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc b/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc new file mode 100644 index 0000000000..9447772568 --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/update_turn_list_request.cc @@ -0,0 +1,227 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <string> +#include "application_manager/commands/mobile/update_turn_list_request.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application_impl.h" +#include "application_manager/message_helper.h" +#include "interfaces/MOBILE_API.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UpdateTurnListRequest::UpdateTurnListRequest(const MessageSharedPtr& message) + : CommandRequestImpl(message) { +} + +UpdateTurnListRequest::~UpdateTurnListRequest() { +} + +void UpdateTurnListRequest::Run() { + LOG4CXX_INFO(logger_, "UpdateTurnListRequest::Run"); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + (*message_)[strings::params][strings::connection_key].asUInt()); + + if (!app) { + SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED); + LOG4CXX_ERROR(logger_, "Application is not registered"); + return; + } + + if (IsWhiteSpaceExist()) { + LOG4CXX_ERROR(logger_, + "Incoming update turn list has contains \t\n \\t \\n"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + //ProcessSoftButtons checks strings on the contents incorrect character + + mobile_apis::Result::eType processing_result = + MessageHelper::ProcessSoftButtons((*message_)[strings::msg_params], app); + + if (mobile_apis::Result::SUCCESS != processing_result) { + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, processing_result); + return; + } + + if ((*message_)[strings::msg_params].keyExists(strings::turn_list)) { + smart_objects::SmartObject& turn_list_array = + ((*message_)[strings::msg_params][strings::turn_list]); + for (uint32_t i = 0; i < turn_list_array.length(); ++i) { + if((turn_list_array[i].keyExists(strings::turn_icon)) && + (mobile_apis::Result::SUCCESS != MessageHelper::VerifyImage( + turn_list_array[i][strings::turn_icon], app))) { + LOG4CXX_ERROR_EXT( + logger_, + "MessageHelper::VerifyImage return INVALID_DATA"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + } + } + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params = (*message_)[strings::msg_params]; + + if ((*message_)[strings::msg_params].keyExists(strings::turn_list)) { + if (!CheckTurnListArray()) { + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + return; + } + + for (uint32_t i = 0; i < msg_params[strings::turn_list].length(); ++i) { + if (msg_params[strings::turn_list][i].keyExists(hmi_request::navi_text)) { + std::string navigation_text = + msg_params[strings::turn_list][i][hmi_request::navi_text].asString(); + msg_params[strings::turn_list][i].erase(hmi_request::navi_text); + msg_params[strings::turn_list] + [i][hmi_request::navi_text][hmi_request::field_name] = + static_cast<int>(hmi_apis::Common_TextFieldName::turnText); + msg_params[strings::turn_list] + [i][hmi_request::navi_text][hmi_request::field_text] = + navigation_text; + } + } + } + + msg_params[strings::app_id] = app->app_id(); + + if ((*message_)[strings::msg_params].keyExists(strings::soft_buttons)) { + MessageHelper::SubscribeApplicationToSoftButton((*message_)[strings::msg_params], + app, function_id()); + } + + if ((*message_)[strings::msg_params].keyExists(strings::turn_list) || + (*message_)[strings::msg_params].keyExists(strings::soft_buttons)) { + SendHMIRequest(hmi_apis::FunctionID::Navigation_UpdateTurnList, &msg_params, + true); + } else { + // conditional mandatory + LOG4CXX_ERROR(logger_, "INVALID_DATA!"); + SendResponse(false, mobile_apis::Result::INVALID_DATA); + } +} + +void UpdateTurnListRequest::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "UpdateTurnListRequest::on_event"); + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { + case hmi_apis::FunctionID::Navigation_UpdateTurnList: { + LOG4CXX_INFO(logger_, "Received Navigation_UpdateTurnList event"); + + mobile_apis::Result::eType result_code = + static_cast<mobile_apis::Result::eType>( + message[strings::params][hmi_response::code].asInt()); + HMICapabilities& hmi_capabilities = + ApplicationManagerImpl::instance()->hmi_capabilities(); + + bool result = (mobile_apis::Result::SUCCESS == result_code) || + ((mobile_apis::Result::UNSUPPORTED_RESOURCE == result_code) && + (hmi_capabilities.is_ui_cooperating())); + + + SendResponse(result, result_code, NULL, &(message[strings::msg_params])); + break; + } + default: { + LOG4CXX_ERROR(logger_,"Received unknown event" << event.id()); + break; + } + } +} + +bool UpdateTurnListRequest::CheckTurnListArray() { + int32_t length = + (*message_)[strings::msg_params][strings::turn_list].length(); + if (0 == length) { + return false; + } + + for (int32_t i = 0; i < length; ++i) { + if (!((*message_)[strings::msg_params][strings::turn_list][i]. + keyExists(hmi_request::navi_text)) && + !((*message_)[strings::msg_params][strings::turn_list][i]. + keyExists(strings::turn_icon))) { + return false; + } + } + return true; +} + +bool UpdateTurnListRequest::IsWhiteSpaceExist() { + LOG4CXX_INFO(logger_, "UpdateTurnListRequest::IsWhiteSpaceExist"); + const char* str = NULL; + + if ((*message_)[strings::msg_params].keyExists(strings::turn_list)) { + const smart_objects::SmartArray* tl_array = + (*message_)[strings::msg_params][strings::turn_list].asArray(); + + smart_objects::SmartArray::const_iterator it_tl = tl_array->begin(); + smart_objects::SmartArray::const_iterator it_tl_end = tl_array->end(); + + for (; it_tl != it_tl_end; ++it_tl) { + if ((*it_tl).keyExists(strings::navigation_text)) { + str = (*it_tl)[strings::navigation_text].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid turn_list navigation_text text syntax check failed"); + return true; + } + } + + if ((*it_tl).keyExists(strings::turn_icon)) { + str = (*it_tl)[strings::turn_icon][strings::value].asCharArray(); + if (!CheckSyntax(str)) { + LOG4CXX_ERROR(logger_, + "Invalid turn_list turn_icon value syntax check failed"); + return true; + } + } + + } + } + return false; +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/mobile/update_turn_list_response.cc b/src/components/application_manager/src/commands/mobile/update_turn_list_response.cc new file mode 100644 index 0000000000..ec1e0bce8a --- /dev/null +++ b/src/components/application_manager/src/commands/mobile/update_turn_list_response.cc @@ -0,0 +1,57 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/mobile/update_turn_list_response.h" +#include "application_manager/application_manager_impl.h" +#include "interfaces/HMI_API.h" + +namespace application_manager { + +namespace commands { + +UpdateTurnListResponse::UpdateTurnListResponse(const MessageSharedPtr& message) + : CommandResponseImpl(message) { +} + +UpdateTurnListResponse::~UpdateTurnListResponse() { +} + +void UpdateTurnListResponse::Run() { + LOG4CXX_INFO(logger_, "UpdateTurnListResponse::Run"); + + ApplicationManagerImpl::instance()->SendMessageToMobile(message_); +} + +} // namespace commands + +} // namespace application_manager diff --git a/src/components/application_manager/src/commands/pending.cc b/src/components/application_manager/src/commands/pending.cc new file mode 100644 index 0000000000..0c04464af3 --- /dev/null +++ b/src/components/application_manager/src/commands/pending.cc @@ -0,0 +1,67 @@ +/* + + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/commands/pending.h" + +namespace application_manager { + +namespace commands { + + +Pending::Pending() +: last_(hmi_apis::FunctionID::INVALID_ENUM) { +} + +Pending::~Pending() { +} + +void Pending::Add(hmi_apis::FunctionID::eType id) { + sync_primitives::AutoLock L(lock_); + pending_.insert(id); +} + +void Pending::Remove(hmi_apis::FunctionID::eType id) { + sync_primitives::AutoLock L(lock_); + pending_.erase(id); + + if (pending_.empty()) { + last_ = id; + } +} + +bool Pending::IsFinal(hmi_apis::FunctionID::eType id) { + return id == last_; +} + +} // namespace commands +} // namespace application_manager diff --git a/src/components/application_manager/src/event_engine/event.cc b/src/components/application_manager/src/event_engine/event.cc new file mode 100644 index 0000000000..e454025df1 --- /dev/null +++ b/src/components/application_manager/src/event_engine/event.cc @@ -0,0 +1,56 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/event_engine/event.h" +#include "application_manager/event_engine/event_dispatcher.h" + +namespace application_manager { +namespace event_engine { + +Event::Event(const EventID& id) +: id_(id) +, response_so_() { +} + +Event::~Event() { +} + +void Event::raise() { + EventDispatcher::instance()->raise_event(*this); +} + +void Event::set_smart_object(smart_objects::SmartObject& so) { + response_so_ = so; +} + +} +} diff --git a/src/components/application_manager/src/event_engine/event_dispatcher.cc b/src/components/application_manager/src/event_engine/event_dispatcher.cc new file mode 100644 index 0000000000..a552ef6228 --- /dev/null +++ b/src/components/application_manager/src/event_engine/event_dispatcher.cc @@ -0,0 +1,123 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "interfaces/HMI_API.h" +#include "application_manager/event_engine/event_observer.h" +#include "application_manager/event_engine/event_dispatcher.h" + +namespace application_manager { +namespace event_engine { +using namespace sync_primitives; + +EventDispatcher::EventDispatcher() + : observers_() { +} + +EventDispatcher::~EventDispatcher() { +} + +void EventDispatcher::raise_event(const Event& event) { + // create local list + ObserverList list; + { + AutoLock auto_lock(state_lock_); + // check if event is notification + if (hmi_apis::messageType::notification == event.smart_object_type()) { + + //ObserversMap iterator + ObserversMap::iterator it = observers_[event.id()].begin(); + for (; observers_[event.id()].end() != it; ++it) { + list = it->second; + } + } + + if (hmi_apis::messageType::response == event.smart_object_type() + || hmi_apis::messageType::error_response == event.smart_object_type()) { + list = observers_[event.id()][event.smart_object_correlation_id()]; + } + } + + // Call observers + ObserverList::iterator observers = list.begin(); + for (; list.end() != observers; ++observers) { + (*observers)->on_event(event); + } +} + +void EventDispatcher::add_observer(const Event::EventID& event_id, + int32_t hmi_correlation_id, + EventObserver* const observer) { + AutoLock auto_lock(state_lock_); + observers_[event_id][hmi_correlation_id].push_back(observer); +} + +void EventDispatcher::remove_observer(const Event::EventID& event_id, + EventObserver* const observer) { + AutoLock auto_lock(state_lock_); + ObserversMap::iterator it = observers_[event_id].begin(); + for (; observers_[event_id].end() != it; ++it) { + + //ObserverList iterator + ObserverList::iterator observer_it = it->second.begin(); + while (it->second.end() != observer_it) { + if (observer->id() == (*observer_it)->id()) { + observer_it = it->second.erase(observer_it); + } else { + ++observer_it; + } + } + } +} + +void EventDispatcher::remove_observer(EventObserver* const observer) { + AutoLock auto_lock(state_lock_); + EventObserverMap::iterator event_map = observers_.begin(); + for (; observers_.end() != event_map; ++event_map) { + + ObserversMap::iterator it = event_map->second.begin(); + for (; event_map->second.end() != it; ++it) { + + //ObserverList iterator + ObserverList::iterator observer_it = it->second.begin(); + while (it->second.end() != observer_it) { + if (observer->id() == (*observer_it)->id()) { + observer_it = it->second.erase(observer_it); + } else { + ++observer_it; + } + } + } + } +} + +} +} diff --git a/src/components/application_manager/src/event_engine/event_observer.cc b/src/components/application_manager/src/event_engine/event_observer.cc new file mode 100644 index 0000000000..c6d81529f9 --- /dev/null +++ b/src/components/application_manager/src/event_engine/event_observer.cc @@ -0,0 +1,63 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/event_engine/event.h" +#include "application_manager/event_engine/event_observer.h" + +namespace application_manager { +namespace event_engine { + +EventObserver::EventObserver() + : id_(0) { + //Get unique id based on this + id_ = reinterpret_cast<unsigned long>(this); +} + +EventObserver::~EventObserver() { + unsubscribe_from_all_events(); +} + +void EventObserver::subscribe_on_event(const Event::EventID& event_id, + int32_t hmi_correlation_id) { + EventDispatcher::instance()->add_observer(event_id, hmi_correlation_id, this); +} + +void EventObserver::unsubscribe_from_event(const Event::EventID& event_id) { + EventDispatcher::instance()->remove_observer(event_id, this); +} + +void EventObserver::unsubscribe_from_all_events() { + EventDispatcher::instance()->remove_observer(this); +} + +} +} diff --git a/src/components/application_manager/src/hmi_capabilities.cc b/src/components/application_manager/src/hmi_capabilities.cc new file mode 100644 index 0000000000..5c67492b48 --- /dev/null +++ b/src/components/application_manager/src/hmi_capabilities.cc @@ -0,0 +1,874 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/hmi_capabilities.h" + +#include <map> + +#include "json/json.h" +#include "utils/file_system.h" +#include "interfaces/HMI_API.h" +#include "config_profile/profile.h" +#include "smart_objects/smart_object.h" +#include "application_manager/smart_object_keys.h" +#include "application_manager/message_helper.h" +#include "application_manager/smart_object_keys.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "formatters/CFormatterJsonBase.hpp" + +namespace application_manager { +namespace Formatters = NsSmartDeviceLink::NsJSONHandler::Formatters; + +CREATE_LOGGERPTR_GLOBAL(logger_, "HMICapabilities") + +std::map<std::string, hmi_apis::Common_Language::eType> languages_enum_values = +{ + {"EN_US", hmi_apis::Common_Language::EN_US}, + {"ES_MX", hmi_apis::Common_Language::ES_MX}, + {"FR_CA", hmi_apis::Common_Language::FR_CA}, + {"DE_DE", hmi_apis::Common_Language::DE_DE}, + {"ES_ES", hmi_apis::Common_Language::ES_ES}, + {"EN_GB", hmi_apis::Common_Language::EN_GB}, + {"RU_RU", hmi_apis::Common_Language::RU_RU}, + {"TR_TR", hmi_apis::Common_Language::TR_TR}, + {"PL_PL", hmi_apis::Common_Language::PL_PL}, + {"FR_FR", hmi_apis::Common_Language::FR_FR}, + {"IT_IT", hmi_apis::Common_Language::IT_IT}, + {"SV_SE", hmi_apis::Common_Language::SV_SE}, + {"PT_PT", hmi_apis::Common_Language::PT_PT}, + {"NL_NL", hmi_apis::Common_Language::NL_NL}, + {"EN_AU", hmi_apis::Common_Language::EN_AU}, + {"ZH_CN", hmi_apis::Common_Language::ZH_CN}, + {"ZH_TW", hmi_apis::Common_Language::ZH_TW}, + {"JA_JP", hmi_apis::Common_Language::JA_JP}, + {"AR_SA", hmi_apis::Common_Language::AR_SA}, + {"KO_KR", hmi_apis::Common_Language::KO_KR}, + {"PT_BR", hmi_apis::Common_Language::PT_BR}, + {"CS_CZ", hmi_apis::Common_Language::CS_CZ}, + {"DA_DK", hmi_apis::Common_Language::DA_DK}, + {"NO_NO", hmi_apis::Common_Language::NO_NO} +}; + +std::map<std::string, hmi_apis::Common_VrCapabilities::eType> vr_enum_capabilities = +{ + {"TEXT", hmi_apis::Common_VrCapabilities::VR_TEXT} +}; + +std::map<std::string, hmi_apis::Common_ButtonName::eType> button_enum_name = +{ + {"OK" , hmi_apis::Common_ButtonName::OK}, + {"SEEKLEFT" , hmi_apis::Common_ButtonName::SEEKLEFT}, + {"SEEKRIGHT" , hmi_apis::Common_ButtonName::SEEKRIGHT}, + {"TUNEUP" , hmi_apis::Common_ButtonName::TUNEUP}, + {"TUNEDOWN" , hmi_apis::Common_ButtonName::TUNEDOWN}, + {"PRESET_0" , hmi_apis::Common_ButtonName::PRESET_0}, + {"PRESET_1" , hmi_apis::Common_ButtonName::PRESET_1}, + {"PRESET_2" , hmi_apis::Common_ButtonName::PRESET_2}, + {"PRESET_3" , hmi_apis::Common_ButtonName::PRESET_3}, + {"PRESET_4" , hmi_apis::Common_ButtonName::PRESET_4}, + {"PRESET_5" , hmi_apis::Common_ButtonName::PRESET_5}, + {"PRESET_6" , hmi_apis::Common_ButtonName::PRESET_6}, + {"PRESET_7" , hmi_apis::Common_ButtonName::PRESET_7}, + {"PRESET_8" , hmi_apis::Common_ButtonName::PRESET_8}, + {"PRESET_9" , hmi_apis::Common_ButtonName::PRESET_9}, + {"CUSTOM_BUTTON" , hmi_apis::Common_ButtonName::CUSTOM_BUTTON}, + {"SEARCH" , hmi_apis::Common_ButtonName::SEARCH}, + +}; + +std::map<std::string, hmi_apis::Common_TextFieldName::eType> text_fields_enum_name = +{ + {"mainField1", hmi_apis::Common_TextFieldName::mainField1}, + {"mainField2", hmi_apis::Common_TextFieldName::mainField2}, + {"mainField3", hmi_apis::Common_TextFieldName::mainField3}, + {"mainField4", hmi_apis::Common_TextFieldName::mainField4}, + {"statusBar" , hmi_apis::Common_TextFieldName::statusBar}, + {"mediaClock", hmi_apis::Common_TextFieldName::mediaClock}, + {"mediaTrack", hmi_apis::Common_TextFieldName::mediaTrack}, + {"alertText1", hmi_apis::Common_TextFieldName::alertText1}, + {"alertText2", hmi_apis::Common_TextFieldName::alertText2}, + {"alertText3", hmi_apis::Common_TextFieldName::alertText3}, + {"scrollableMessageBody" , hmi_apis::Common_TextFieldName::scrollableMessageBody}, + {"initialInteractionText", hmi_apis::Common_TextFieldName::initialInteractionText}, + {"navigationText1" , hmi_apis::Common_TextFieldName::navigationText1}, + {"navigationText2" , hmi_apis::Common_TextFieldName::navigationText2}, + {"ETA" , hmi_apis::Common_TextFieldName::ETA}, + {"totalDistance" , hmi_apis::Common_TextFieldName::totalDistance}, + {"audioPassThruDisplayText1", hmi_apis::Common_TextFieldName::audioPassThruDisplayText1}, + {"audioPassThruDisplayText2", hmi_apis::Common_TextFieldName::audioPassThruDisplayText2}, + {"sliderHeader" , hmi_apis::Common_TextFieldName::sliderHeader}, + {"sliderFooter" , hmi_apis::Common_TextFieldName::sliderFooter}, + {"notificationText" , hmi_apis::Common_TextFieldName::notificationText}, + {"menuName" , hmi_apis::Common_TextFieldName::menuName}, + {"secondaryText" , hmi_apis::Common_TextFieldName::secondaryText}, + {"tertiaryText" , hmi_apis::Common_TextFieldName::tertiaryText}, + {"timeToDestination", hmi_apis::Common_TextFieldName::timeToDestination}, + {"turnText" , hmi_apis::Common_TextFieldName::turnText}, + {"menuTitle" , hmi_apis::Common_TextFieldName::menuTitle}, +}; + +std::map<std::string, hmi_apis::Common_MediaClockFormat::eType> media_clock_enum_name = +{ + {"CLOCK1" , hmi_apis::Common_MediaClockFormat::CLOCK1}, + {"CLOCK2" , hmi_apis::Common_MediaClockFormat::CLOCK2}, + {"CLOCK3" , hmi_apis::Common_MediaClockFormat::CLOCK3}, + {"CLOCKTEXT1", hmi_apis::Common_MediaClockFormat::CLOCKTEXT1}, + {"CLOCKTEXT2", hmi_apis::Common_MediaClockFormat::CLOCKTEXT2}, + {"CLOCKTEXT3", hmi_apis::Common_MediaClockFormat::CLOCKTEXT3}, + {"CLOCKTEXT4", hmi_apis::Common_MediaClockFormat::CLOCKTEXT4}, +}; + +std::map<std::string, hmi_apis::Common_ImageType::eType> image_type_enum = +{ + {"STATIC" , hmi_apis::Common_ImageType::STATIC}, + {"DYNAMIC", hmi_apis::Common_ImageType::DYNAMIC} +}; + +std::map<std::string, hmi_apis::Common_SamplingRate::eType> sampling_rate_enum = +{ + {"8KHZ" , hmi_apis::Common_SamplingRate::RATE_8KHZ}, + {"16KHZ", hmi_apis::Common_SamplingRate::RATE_16KHZ}, + {"22KHZ", hmi_apis::Common_SamplingRate::RATE_22KHZ}, + {"44KHZ", hmi_apis::Common_SamplingRate::RATE_44KHZ} +}; + +std::map<std::string, hmi_apis::Common_BitsPerSample::eType> bit_per_sample_enum = +{ + {"RATE_8_BIT", hmi_apis::Common_BitsPerSample::RATE_8_BIT}, + {"RATE_16_BIT", hmi_apis::Common_BitsPerSample::RATE_16_BIT} +}; + +std::map<std::string, hmi_apis::Common_AudioType::eType> audio_type_enum = +{ + {"PCM", hmi_apis::Common_AudioType::PCM} +}; + +std::map<std::string, hmi_apis::Common_HmiZoneCapabilities::eType> hmi_zone_enum = +{ + {"FRONT", hmi_apis::Common_HmiZoneCapabilities::FRONT}, + {"BACK", hmi_apis::Common_HmiZoneCapabilities::BACK}, +}; + +const std::map<std::string, hmi_apis::Common_ImageFieldName::eType> +image_field_name_enum = +{ + {"softButtonImage", hmi_apis::Common_ImageFieldName::softButtonImage}, + {"choiceImage", hmi_apis::Common_ImageFieldName::choiceImage}, + {"choiceSecondaryImage", hmi_apis::Common_ImageFieldName::choiceSecondaryImage}, + {"vrHelpItem", hmi_apis::Common_ImageFieldName::vrHelpItem}, + {"turnIcon", hmi_apis::Common_ImageFieldName::turnIcon}, + {"menuIcon", hmi_apis::Common_ImageFieldName::menuIcon}, + {"cmdIcon", hmi_apis::Common_ImageFieldName::cmdIcon}, + {"appIcon", hmi_apis::Common_ImageFieldName::appIcon}, + {"graphic", hmi_apis::Common_ImageFieldName::graphic}, + {"showConstantTBTIcon", hmi_apis::Common_ImageFieldName::showConstantTBTIcon}, + {"showConstantTBTNextTurnIcon", + hmi_apis::Common_ImageFieldName::showConstantTBTNextTurnIcon} +}; + +const std::map<std::string, hmi_apis::Common_FileType::eType> file_type_enum = +{ + {"GRAPHIC_BMP", hmi_apis::Common_FileType::GRAPHIC_BMP}, + {"GRAPHIC_JPEG", hmi_apis::Common_FileType::GRAPHIC_JPEG}, + {"GRAPHIC_PNG", hmi_apis::Common_FileType::GRAPHIC_PNG}, + {"AUDIO_WAVE", hmi_apis::Common_FileType::AUDIO_WAVE}, + {"AUDIO_MP3", hmi_apis::Common_FileType::AUDIO_MP3}, + {"AUDIO_AAC", hmi_apis::Common_FileType::AUDIO_AAC}, + {"BINARY", hmi_apis::Common_FileType::BINARY}, + {"JSON", hmi_apis::Common_FileType::JSON} +}; + +const std::map<std::string, hmi_apis::Common_DisplayType::eType> display_type_enum = +{ + {"CID", hmi_apis::Common_DisplayType::CID}, + {"TYPE2", hmi_apis::Common_DisplayType::TYPE2}, + {"TYPE5", hmi_apis::Common_DisplayType::TYPE5}, + {"NGN", hmi_apis::Common_DisplayType::NGN}, + {"GEN2_8_DMA", hmi_apis::Common_DisplayType::GEN2_8_DMA}, + {"GEN2_6_DMA", hmi_apis::Common_DisplayType::GEN2_6_DMA}, + {"MFD3", hmi_apis::Common_DisplayType::MFD3}, + {"MFD4", hmi_apis::Common_DisplayType::MFD4}, + {"MFD5", hmi_apis::Common_DisplayType::MFD5}, + {"GEN3_8_INCH", hmi_apis::Common_DisplayType::GEN3_8_INCH} +}; + +const std::map<std::string, hmi_apis::Common_CharacterSet::eType> character_set_enum = +{ + {"TYPE2SET" , hmi_apis::Common_CharacterSet::TYPE2SET}, + {"TYPE5SET" , hmi_apis::Common_CharacterSet::TYPE5SET}, + {"CID1SET" , hmi_apis::Common_CharacterSet::CID1SET}, + {"CID2SET" , hmi_apis::Common_CharacterSet::CID2SET} +}; + +HMICapabilities::HMICapabilities(ApplicationManagerImpl* const app_mngr) + : is_vr_cooperating_(false), + is_tts_cooperating_(false), + is_ui_cooperating_(false), + is_navi_cooperating_(false), + is_ivi_cooperating_(false), + is_vr_ready_response_recieved_(false), + is_tts_ready_response_recieved_(false), + is_ui_ready_response_recieved_(false), + is_navi_ready_response_recieved_(false), + is_ivi_ready_response_recieved_(false), + attenuated_supported_(false), + ui_language_(hmi_apis::Common_Language::INVALID_ENUM), + vr_language_(hmi_apis::Common_Language::INVALID_ENUM), + tts_language_(hmi_apis::Common_Language::INVALID_ENUM), + vehicle_type_(NULL), + ui_supported_languages_(NULL), + tts_supported_languages_(NULL), + vr_supported_languages_(NULL), + display_capabilities_(NULL), + hmi_zone_capabilities_(NULL), + soft_buttons_capabilities_(NULL), + button_capabilities_(NULL), + preset_bank_capabilities_(NULL), + vr_capabilities_(NULL), + speech_capabilities_(NULL), + audio_pass_thru_capabilities_(NULL), + prerecorded_speech_(NULL), + app_mngr_(app_mngr) { + + if (false == load_capabilities_from_file()) { + LOG4CXX_ERROR(logger_, "file hmi_capabilities.json was not loaded"); + } else { + LOG4CXX_INFO(logger_, "file hmi_capabilities.json was loaded"); + } + if (false == profile::Profile::instance()->launch_hmi()) { + is_vr_ready_response_recieved_ = true; + is_tts_ready_response_recieved_ = true; + is_ui_ready_response_recieved_ = true; + is_navi_ready_response_recieved_ = true; + is_ivi_ready_response_recieved_ = true; + + is_vr_cooperating_ = true; + is_tts_cooperating_ = true; + is_ui_cooperating_ = true; + is_navi_cooperating_ = true; + is_ivi_cooperating_ = true; + } +} + +HMICapabilities::~HMICapabilities() { + delete vehicle_type_; + delete ui_supported_languages_; + delete tts_supported_languages_; + delete vr_supported_languages_; + delete display_capabilities_; + delete hmi_zone_capabilities_; + delete soft_buttons_capabilities_; + delete button_capabilities_; + delete preset_bank_capabilities_; + delete vr_capabilities_; + delete speech_capabilities_; + delete audio_pass_thru_capabilities_; + delete prerecorded_speech_; + app_mngr_ = NULL; +} + +bool HMICapabilities::is_hmi_capabilities_initialized() const { + bool result = true; + + if (is_vr_ready_response_recieved_ && is_tts_ready_response_recieved_ + && is_ui_ready_response_recieved_ && is_navi_ready_response_recieved_ + && is_ivi_ready_response_recieved_) { + if (is_vr_cooperating_) { + if ((!vr_supported_languages_) || + (hmi_apis::Common_Language::INVALID_ENUM == vr_language_)) { + result = false; + } + } + + if (is_tts_cooperating_) { + if ((!tts_supported_languages_) || + (hmi_apis::Common_Language::INVALID_ENUM == tts_language_)) { + result = false; + } + } + + if (is_ui_cooperating_) { + if ((!ui_supported_languages_) || + (hmi_apis::Common_Language::INVALID_ENUM == ui_language_)) { + result = false; + } + } + + if (is_ivi_cooperating_) { + if (!vehicle_type_) { + result = false; + } + } + } else { + result = false; + } + + return result; +} + +bool HMICapabilities::VerifyImageType(int32_t image_type) const { + if (!display_capabilities_) { + return false; + } + + if (display_capabilities_->keyExists(hmi_response::image_capabilities)) { + const smart_objects::SmartObject& image_caps = display_capabilities_ + ->getElement(hmi_response::image_capabilities); + for (uint32_t i = 0; i < image_caps.length(); ++i) { + if (image_caps.getElement(i).asInt() == image_type) { + return true; + } + } + } + + return false; +} + +void HMICapabilities::set_is_vr_cooperating(bool value) { + is_vr_ready_response_recieved_ = true; + is_vr_cooperating_ = value; + if (is_vr_cooperating_) { + utils::SharedPtr<smart_objects::SmartObject> get_language( + MessageHelper::CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetLanguage)); + app_mngr_->ManageHMICommand(get_language); + utils::SharedPtr<smart_objects::SmartObject> get_all_languages( + MessageHelper::CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetSupportedLanguages)); + app_mngr_->ManageHMICommand(get_all_languages); + utils::SharedPtr<smart_objects::SmartObject> get_capabilities( + MessageHelper::CreateModuleInfoSO(hmi_apis::FunctionID::VR_GetCapabilities)); + app_mngr_->ManageHMICommand(get_capabilities); + } +} + +void HMICapabilities::set_is_tts_cooperating(bool value) { + is_tts_ready_response_recieved_ = true; + is_tts_cooperating_ = value; + if (is_tts_cooperating_) { + utils::SharedPtr<smart_objects::SmartObject> get_language( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::TTS_GetLanguage)); + app_mngr_->ManageHMICommand(get_language); + utils::SharedPtr<smart_objects::SmartObject> get_all_languages( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::TTS_GetSupportedLanguages)); + app_mngr_->ManageHMICommand(get_all_languages); + utils::SharedPtr<smart_objects::SmartObject> get_capabilities( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::TTS_GetCapabilities)); + app_mngr_->ManageHMICommand(get_capabilities); + } +} + +void HMICapabilities::set_is_ui_cooperating(bool value) { + is_ui_ready_response_recieved_ = true; + is_ui_cooperating_ = value; + if (is_ui_cooperating_) { + utils::SharedPtr<smart_objects::SmartObject> get_language( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::UI_GetLanguage)); + app_mngr_->ManageHMICommand(get_language); + utils::SharedPtr<smart_objects::SmartObject> get_all_languages( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::UI_GetSupportedLanguages)); + app_mngr_->ManageHMICommand(get_all_languages); + utils::SharedPtr<smart_objects::SmartObject> get_capabilities( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::UI_GetCapabilities)); + app_mngr_->ManageHMICommand(get_capabilities); + } +} + +void HMICapabilities::set_is_navi_cooperating(bool value) { + is_navi_ready_response_recieved_ = true; + is_navi_cooperating_ = value; +} + +void HMICapabilities::set_is_ivi_cooperating(bool value) { + is_ivi_ready_response_recieved_ = true; + is_ivi_cooperating_ = value; + if (is_ivi_cooperating_) { + utils::SharedPtr<smart_objects::SmartObject> get_type( + MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::VehicleInfo_GetVehicleType)); + app_mngr_->ManageHMICommand(get_type); + } +} + +void HMICapabilities::set_attenuated_supported(bool state) { + attenuated_supported_ = state; +} + +void HMICapabilities::set_active_ui_language( + const hmi_apis::Common_Language::eType& language) { + ui_language_ = language; +} + +void HMICapabilities::set_active_vr_language( + const hmi_apis::Common_Language::eType& language) { + vr_language_ = language; +} + +void HMICapabilities::set_active_tts_language( + const hmi_apis::Common_Language::eType& language) { + tts_language_ = language; +} + +void HMICapabilities::set_ui_supported_languages( + const smart_objects::SmartObject& supported_languages) { + if (ui_supported_languages_) { + delete ui_supported_languages_; + } + ui_supported_languages_ = new smart_objects::SmartObject(supported_languages); +} + +void HMICapabilities::set_tts_supported_languages( + const smart_objects::SmartObject& supported_languages) { + if (tts_supported_languages_) { + delete tts_supported_languages_; + } + tts_supported_languages_ = new smart_objects::SmartObject( + supported_languages); +} + +void HMICapabilities::set_vr_supported_languages( + const smart_objects::SmartObject& supported_languages) { + if (vr_supported_languages_) { + delete vr_supported_languages_; + } + vr_supported_languages_ = new smart_objects::SmartObject(supported_languages); +} + +void HMICapabilities::set_display_capabilities( + const smart_objects::SmartObject& display_capabilities) { + if (display_capabilities_) { + delete display_capabilities_; + } + display_capabilities_ = new smart_objects::SmartObject(display_capabilities); +} + +void HMICapabilities::set_hmi_zone_capabilities( + const smart_objects::SmartObject& hmi_zone_capabilities) { + if (hmi_zone_capabilities_) { + delete hmi_zone_capabilities_; + } + hmi_zone_capabilities_ = new smart_objects::SmartObject( + hmi_zone_capabilities); +} + +void HMICapabilities::set_soft_button_capabilities( + const smart_objects::SmartObject& soft_button_capabilities) { + if (soft_buttons_capabilities_) { + delete soft_buttons_capabilities_; + } + soft_buttons_capabilities_ = new smart_objects::SmartObject( + soft_button_capabilities); +} + +void HMICapabilities::set_button_capabilities( + const smart_objects::SmartObject& button_capabilities) { + if (button_capabilities_) { + delete button_capabilities_; + } + button_capabilities_ = new smart_objects::SmartObject(button_capabilities); +} + +void HMICapabilities::set_vr_capabilities( + const smart_objects::SmartObject& vr_capabilities) { + if (vr_capabilities_) { + delete vr_capabilities_; + } + vr_capabilities_ = new smart_objects::SmartObject(vr_capabilities); +} + +void HMICapabilities::set_speech_capabilities( + const smart_objects::SmartObject& speech_capabilities) { + if (speech_capabilities_) { + delete speech_capabilities_; + } + speech_capabilities_ = new smart_objects::SmartObject(speech_capabilities); +} + +void HMICapabilities::set_audio_pass_thru_capabilities( + const smart_objects::SmartObject& audio_pass_thru_capabilities) { + if (audio_pass_thru_capabilities_) { + delete audio_pass_thru_capabilities_; + } + audio_pass_thru_capabilities_ = new smart_objects::SmartObject( + audio_pass_thru_capabilities); +} + +void HMICapabilities::set_preset_bank_capabilities( + const smart_objects::SmartObject& preset_bank_capabilities) { + if (preset_bank_capabilities_) { + delete preset_bank_capabilities_; + } + preset_bank_capabilities_ = new smart_objects::SmartObject( + preset_bank_capabilities); +} + +void HMICapabilities::set_vehicle_type( + const smart_objects::SmartObject& vehicle_type) { + if (vehicle_type_) { + delete vehicle_type_; + } + vehicle_type_ = new smart_objects::SmartObject(vehicle_type); +} + +void HMICapabilities::set_prerecorded_speech( + const smart_objects::SmartObject& prerecorded_speech) { + if (prerecorded_speech_) { + delete prerecorded_speech_; + prerecorded_speech_ = NULL; + } + prerecorded_speech_ = new smart_objects::SmartObject(prerecorded_speech); +} + +bool HMICapabilities::load_capabilities_from_file() { + std::string json_string; + std::string file_name = + profile::Profile::instance()->hmi_capabilities_file_name(); + + if (!file_system::FileExists(file_name)) { + return false; + } + + if (!file_system::ReadFile(file_name, json_string)) { + return false; + } + + try { + + Json::Reader reader_; + Json::Value root_json; + + bool result = reader_.parse(json_string, root_json, false); + if (!result) { + return false; + } + // UI + if (check_existing_json_member(root_json, "UI")) { + Json::Value ui = root_json.get("UI", ""); + + if (check_existing_json_member(ui, "language")) { + set_active_ui_language( + languages_enum_values.find(ui.get("language", "").asString())->second); + } + + if (check_existing_json_member(ui, "languages")) { + smart_objects::SmartObject ui_languages_so( + smart_objects::SmartType_Array); + Json::Value languages_ui = ui.get("languages", ""); + convert_json_languages_to_obj(languages_ui, ui_languages_so); + set_ui_supported_languages(ui_languages_so); + } + + if (check_existing_json_member(ui, "displayCapabilities")) { + smart_objects::SmartObject display_capabilities_so; + Json::Value display_capabilities = ui.get("displayCapabilities", ""); + Formatters::CFormatterJsonBase::jsonValueToObj( + display_capabilities, display_capabilities_so); + + if (display_capabilities_so.keyExists(hmi_response::display_type)) { + std::map<std::string, hmi_apis::Common_DisplayType::eType> + ::const_iterator it = display_type_enum.find( + (display_capabilities_so[hmi_response::display_type]).asString()); + display_capabilities_so.erase(hmi_response::display_type); + if (display_type_enum.end() != it) { + display_capabilities_so[hmi_response::display_type] = it->second; + } + } + + if (display_capabilities_so.keyExists(hmi_response::text_fields)) { + uint32_t len = + display_capabilities_so[hmi_response::text_fields].length(); + + for (uint32_t i = 0; i < len; ++i) { + + if ((display_capabilities_so + [hmi_response::text_fields][i]).keyExists(strings::name)) { + std::map<std::string, hmi_apis::Common_TextFieldName::eType> + ::const_iterator it_text_field_name = text_fields_enum_name.find( + display_capabilities_so[hmi_response::text_fields] + [i][strings::name].asString()); + display_capabilities_so[hmi_response::text_fields][i].erase(strings::name); + if (text_fields_enum_name.end() != it_text_field_name) { + display_capabilities_so[hmi_response::text_fields] + [i][strings::name] = it_text_field_name->second; + } + } + if ((display_capabilities_so + [hmi_response::text_fields][i]).keyExists(strings::character_set)) { + std::map<std::string, hmi_apis::Common_CharacterSet::eType> + ::const_iterator it_characte_set = character_set_enum.find( + display_capabilities_so[hmi_response::text_fields] + [i][strings::character_set].asString()); + display_capabilities_so + [hmi_response::text_fields][i].erase(strings::character_set); + if (character_set_enum.end() != it_characte_set) { + display_capabilities_so + [hmi_response::text_fields][i][strings::character_set] = + it_characte_set->second; + } + } + } + } + + if (display_capabilities_so.keyExists(hmi_response::image_fields)) { + smart_objects::SmartObject& array_image_fields = + display_capabilities_so[hmi_response::image_fields]; + for (uint32_t i = 0; i < array_image_fields.length(); ++i) { + if (array_image_fields[i].keyExists(strings::name)) { + std::map<std::string, hmi_apis::Common_ImageFieldName::eType> + ::const_iterator it = image_field_name_enum.find( + (array_image_fields[i][strings::name]).asString()); + array_image_fields[i].erase(strings::name); + if (image_field_name_enum.end() != it) { + array_image_fields[i][strings::name] = it->second; + } + } + if (array_image_fields[i].keyExists(strings::image_type_supported)) { + smart_objects::SmartObject& image_type_supported_array = + array_image_fields[i][strings::image_type_supported]; + smart_objects::SmartObject image_type_supported_enum( + smart_objects::SmartType_Array); + for (uint32_t k = 0, j = 0; k < image_type_supported_array.length(); ++k) { + std::map<std::string, hmi_apis::Common_FileType::eType> + ::const_iterator it = file_type_enum.find( + (image_type_supported_array[k]).asString()); + if (file_type_enum.end() != it) { + image_type_supported_enum[j++] = it->second; + } + } + array_image_fields[i].erase(strings::image_type_supported); + array_image_fields[i][strings::image_type_supported] = + image_type_supported_enum; + } + } + } + if (display_capabilities_so.keyExists(hmi_response::media_clock_formats)) { + smart_objects::SmartObject& media_clock_formats_array = + display_capabilities_so[hmi_response::media_clock_formats]; + smart_objects::SmartObject media_clock_formats_enum( + smart_objects::SmartType_Array); + for (uint32_t i = 0, j = 0; i < media_clock_formats_array.length(); ++i) { + std::map<std::string, hmi_apis::Common_MediaClockFormat::eType> + ::const_iterator it = media_clock_enum_name.find( + (media_clock_formats_array[i]).asString()); + if (media_clock_enum_name.end() != it) { + media_clock_formats_enum[j++] = it->second; + } + } + display_capabilities_so.erase(hmi_response::media_clock_formats); + display_capabilities_so[hmi_response::media_clock_formats] = + media_clock_formats_enum; + } + + if (display_capabilities_so.keyExists(hmi_response::image_capabilities)) { + smart_objects::SmartObject& image_capabilities_array = + display_capabilities_so[hmi_response::image_capabilities]; + smart_objects::SmartObject image_capabilities_enum( + smart_objects::SmartType_Array); + for (uint32_t i = 0, j = 0; i < image_capabilities_array.length(); ++i) { + std::map<std::string, hmi_apis::Common_ImageType::eType> + ::const_iterator it = image_type_enum.find( + (image_capabilities_array[i]).asString()); + if (image_type_enum.end() != it) { + image_capabilities_enum[j++] = it->second; + } + } + display_capabilities_so.erase(hmi_response::image_capabilities); + display_capabilities_so[hmi_response::image_capabilities] = + image_capabilities_enum; + } + set_display_capabilities(display_capabilities_so); + } + + if (check_existing_json_member(ui, "audioPassThruCapabilities")) { + Json::Value audio_capabilities = ui.get("audioPassThruCapabilities", ""); + smart_objects::SmartObject audio_capabilities_so = + smart_objects::SmartObject(smart_objects::SmartType_Array); + int32_t i = 0; + audio_capabilities_so[i] = + smart_objects::SmartObject(smart_objects::SmartType_Map); + if (check_existing_json_member(audio_capabilities, "samplingRate")) { + audio_capabilities_so[i]["samplingRate"] = + sampling_rate_enum.find( + audio_capabilities.get("samplingRate", "").asString())->second; + } + if (check_existing_json_member(audio_capabilities, "bitsPerSample")) { + audio_capabilities_so[i]["bitsPerSample"] = + bit_per_sample_enum.find( + audio_capabilities.get("bitsPerSample", "").asString())->second; + } + if (check_existing_json_member(audio_capabilities, "audioType")) { + audio_capabilities_so[i]["audioType"] = + audio_type_enum.find( + audio_capabilities.get("audioType", "").asString())->second; + } + set_audio_pass_thru_capabilities(audio_capabilities_so); + } + + if (check_existing_json_member(ui, "hmiZoneCapabilities")) { + smart_objects::SmartObject hmi_zone_capabilities_so = + smart_objects::SmartObject(smart_objects::SmartType_Array); + int32_t index = 0; + hmi_zone_capabilities_so[index] = + hmi_zone_enum.find(ui.get("hmiZoneCapabilities", "").asString())->second; + set_hmi_zone_capabilities(hmi_zone_capabilities_so); + } + + if (check_existing_json_member(ui, "softButtonCapabilities")) { + Json::Value soft_button_capabilities = ui.get( + "softButtonCapabilities", ""); + smart_objects::SmartObject soft_button_capabilities_so; + Formatters::CFormatterJsonBase::jsonValueToObj( + soft_button_capabilities, soft_button_capabilities_so); + set_soft_button_capabilities(soft_button_capabilities_so); + } + } //UI end + + // VR + if (check_existing_json_member(root_json, "VR")) { + Json::Value vr = root_json.get("VR", ""); + if (check_existing_json_member(vr, "language")) { + set_active_vr_language( + languages_enum_values.find(vr.get("language", "").asString())->second); + } + + if (check_existing_json_member(vr, "languages")) { + Json::Value languages_vr = vr.get("languages", ""); + smart_objects::SmartObject vr_languages_so = + smart_objects::SmartObject(smart_objects::SmartType_Array); + convert_json_languages_to_obj(languages_vr, vr_languages_so); + set_vr_supported_languages(vr_languages_so); + } + + if (check_existing_json_member(vr, "capabilities")) { + Json::Value capabilities = vr.get("capabilities", ""); + smart_objects::SmartObject vr_capabilities_so = + smart_objects::SmartObject(smart_objects::SmartType_Array); + for (uint32_t i = 0; i < capabilities.size(); ++i) { + vr_capabilities_so[i] = + vr_enum_capabilities.find(capabilities[i].asString())->second; + } + set_vr_capabilities(vr_capabilities_so); + } + }//VR end + + //TTS + if (check_existing_json_member(root_json, "TTS")) { + Json::Value tts = root_json.get("TTS", ""); + + if (check_existing_json_member(tts, "language")) { + set_active_tts_language( + languages_enum_values.find(tts.get("language", "").asString())->second); + } + + if (check_existing_json_member(tts, "languages")) { + Json::Value languages_tts = tts.get("languages", ""); + smart_objects::SmartObject tts_languages_so = + smart_objects::SmartObject(smart_objects::SmartType_Array); + convert_json_languages_to_obj(languages_tts, tts_languages_so); + set_tts_supported_languages(tts_languages_so); + } + + if (check_existing_json_member(tts, "capabilities")) { + set_speech_capabilities( + smart_objects::SmartObject(tts.get("capabilities", "").asString())); + } + } //TTS end + + // Buttons + if (check_existing_json_member(root_json, "Buttons")) { + Json::Value buttons = root_json.get("Buttons", ""); + if (check_existing_json_member(buttons, "capabilities")) { + Json::Value bt_capabilities = buttons.get("capabilities", ""); + smart_objects::SmartObject buttons_capabilities_so; + Formatters::CFormatterJsonBase::jsonValueToObj( + bt_capabilities, buttons_capabilities_so); + + for (uint32_t i = 0; i < buttons_capabilities_so.length(); ++i) { + if ((buttons_capabilities_so[i]).keyExists(strings::name)) { + std::map<std::string, hmi_apis::Common_ButtonName::eType> + ::const_iterator it = button_enum_name.find( + (buttons_capabilities_so[i][strings::name]).asString()); + buttons_capabilities_so[i].erase(strings::name); + if (button_enum_name.end() != it) { + buttons_capabilities_so[i][strings::name] = it->second; + } + } + } + set_button_capabilities(buttons_capabilities_so); + } + if (check_existing_json_member(buttons, "presetBankCapabilities")) { + Json::Value presetBank = buttons.get("presetBankCapabilities", ""); + smart_objects::SmartObject preset_bank_so; + Formatters::CFormatterJsonBase::jsonValueToObj( + presetBank, preset_bank_so); + set_preset_bank_capabilities(preset_bank_so); + } + } //Buttons end + + //VehicleType + if (check_existing_json_member(root_json, "VehicleInfo")) { + Json::Value vehicle_info = root_json.get("VehicleInfo", ""); + smart_objects::SmartObject vehicle_type_so; + Formatters::CFormatterJsonBase::jsonValueToObj( + vehicle_info, vehicle_type_so); + set_vehicle_type(vehicle_type_so); + }// VehicleType end + + + } catch (...) { + return false; + } + return true; +} + +bool HMICapabilities::check_existing_json_member( + const Json::Value& json_member, const char* name_of_member) { + return json_member.isMember(name_of_member); +} + +void HMICapabilities::convert_json_languages_to_obj(Json::Value& json_languages, + smart_objects::SmartObject& languages) { + for (uint32_t i = 0, j = 0; i < json_languages.size(); ++i) { + std::map<std::string, hmi_apis::Common_Language::eType>::const_iterator it = + languages_enum_values.find(json_languages[i].asString()); + if (languages_enum_values.end() != it) { + languages[j++] = it->second; + } + } +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/hmi_command_factory.cc b/src/components/application_manager/src/hmi_command_factory.cc new file mode 100644 index 0000000000..1416b6c0fa --- /dev/null +++ b/src/components/application_manager/src/hmi_command_factory.cc @@ -0,0 +1,2043 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/hmi_command_factory.h" + +#include "application_manager/message.h" +#include "interfaces/HMI_API.h" + +#include "application_manager/commands/hmi/update_device_list_request.h" +#include "application_manager/commands/hmi/update_device_list_response.h" +#include "application_manager/commands/hmi/on_update_device_list.h" +#include "application_manager/commands/hmi/on_start_device_discovery.h" +#include "application_manager/commands/hmi/update_app_list_request.h" +#include "application_manager/commands/hmi/update_app_list_response.h" +#include "application_manager/commands/hmi/on_find_applications.h" +#include "application_manager/commands/hmi/allow_all_apps_request.h" +#include "application_manager/commands/hmi/allow_all_apps_response.h" +#include "application_manager/commands/hmi/allow_app_request.h" +#include "application_manager/commands/hmi/allow_app_response.h" +#include "application_manager/commands/hmi/sdl_get_list_of_permissions_request.h" +#include "application_manager/commands/hmi/sdl_get_list_of_permissions_response.h" +#include "application_manager/commands/hmi/sdl_get_user_friendly_message_request.h" +#include "application_manager/commands/hmi/sdl_get_user_friendly_message_response.h" +#include "application_manager/commands/hmi/sdl_get_status_update_request.h" +#include "application_manager/commands/hmi/sdl_get_status_update_response.h" +#include "application_manager/commands/hmi/on_status_update_notification.h" +#include "application_manager/commands/hmi/update_sdl_request.h" +#include "application_manager/commands/hmi/update_sdl_response.h" +#include "application_manager/commands/hmi/activate_app_request.h" +#include "application_manager/commands/hmi/activate_app_response.h" +#include "application_manager/commands/hmi/mixing_audio_supported_request.h" +#include "application_manager/commands/hmi/mixing_audio_supported_response.h" +#include "application_manager/commands/hmi/on_allow_sdl_functionality_notification.h" +#include "application_manager/commands/hmi/on_app_permission_changed_notification.h" +#include "application_manager/commands/hmi/on_app_permission_consent_notification.h" +#include "application_manager/commands/hmi/on_app_activated_notification.h" +#include "application_manager/commands/hmi/on_sdl_consent_needed_notification.h" +#include "application_manager/commands/hmi/on_exit_all_applications_notification.h" +#include "application_manager/commands/hmi/on_exit_application_notification.h" +#include "application_manager/commands/hmi/on_put_file_notification.h" +#include "application_manager/commands/hmi/on_resume_audio_source_notification.h" +#include "application_manager/commands/hmi/on_ignition_cycle_over_notification.h" +#include "application_manager/commands/hmi/on_system_info_changed_notification.h" +#include "application_manager/commands/hmi/get_system_info_request.h" +#include "application_manager/commands/hmi/get_system_info_response.h" +#include "application_manager/commands/hmi/close_popup_request.h" +#include "application_manager/commands/hmi/close_popup_response.h" +#include "application_manager/commands/hmi/button_get_capabilities_request.h" +#include "application_manager/commands/hmi/button_get_capabilities_response.h" +#include "application_manager/commands/hmi/ui_add_command_request.h" +#include "application_manager/commands/hmi/ui_add_command_response.h" +#include "application_manager/commands/hmi/ui_delete_command_request.h" +#include "application_manager/commands/hmi/ui_delete_command_response.h" +#include "application_manager/commands/hmi/ui_add_submenu_request.h" +#include "application_manager/commands/hmi/ui_add_submenu_response.h" +#include "application_manager/commands/hmi/ui_delete_submenu_request.h" +#include "application_manager/commands/hmi/ui_delete_submenu_response.h" +#include "application_manager/commands/hmi/ui_get_supported_languages_request.h" +#include "application_manager/commands/hmi/ui_get_supported_languages_response.h" +#include "application_manager/commands/hmi/ui_get_language_request.h" +#include "application_manager/commands/hmi/ui_get_language_response.h" +#include "application_manager/commands/hmi/ui_get_capabilities_request.h" +#include "application_manager/commands/hmi/ui_get_capabilities_response.h" +#include "application_manager/commands/hmi/ui_change_registration_request.h" +#include "application_manager/commands/hmi/ui_change_registration_response.h" +#include "application_manager/commands/hmi/ui_show_request.h" +#include "application_manager/commands/hmi/ui_show_response.h" +#include "application_manager/commands/hmi/ui_alert_request.h" +#include "application_manager/commands/hmi/ui_alert_response.h" +#include "application_manager/commands/hmi/ui_is_ready_request.h" +#include "application_manager/commands/hmi/ui_is_ready_response.h" +#include "application_manager/commands/hmi/ui_slider_request.h" +#include "application_manager/commands/hmi/ui_slider_response.h" +#include "application_manager/commands/hmi/ui_set_media_clock_timer_request.h" +#include "application_manager/commands/hmi/ui_set_media_clock_timer_response.h" +#include "application_manager/commands/hmi/ui_set_global_properties_request.h" +#include "application_manager/commands/hmi/ui_set_global_properties_response.h" +#include "application_manager/commands/hmi/ui_scrollable_message_request.h" +#include "application_manager/commands/hmi/ui_scrollable_message_response.h" +#include "application_manager/commands/hmi/ui_set_icon_request.h" +#include "application_manager/commands/hmi/ui_set_icon_response.h" +#include "application_manager/commands/hmi/ui_perform_audio_pass_thru_response.h" +#include "application_manager/commands/hmi/ui_perform_audio_pass_thru_request.h" +#include "application_manager/commands/hmi/ui_end_audio_pass_thru_response.h" +#include "application_manager/commands/hmi/ui_end_audio_pass_thru_request.h" +#include "application_manager/commands/hmi/ui_perform_interaction_request.h" +#include "application_manager/commands/hmi/ui_perform_interaction_response.h" +#include "application_manager/commands/hmi/vr_is_ready_request.h" +#include "application_manager/commands/hmi/vr_is_ready_response.h" +#include "application_manager/commands/hmi/vr_add_command_request.h" +#include "application_manager/commands/hmi/vr_add_command_response.h" +#include "application_manager/commands/hmi/vr_delete_command_request.h" +#include "application_manager/commands/hmi/vr_delete_command_response.h" +#include "application_manager/commands/hmi/vr_change_registration_request.h" +#include "application_manager/commands/hmi/vr_change_registration_response.h" +#include "application_manager/commands/hmi/vr_get_supported_languages_request.h" +#include "application_manager/commands/hmi/vr_get_supported_languages_response.h" +#include "application_manager/commands/hmi/vr_get_language_request.h" +#include "application_manager/commands/hmi/vr_get_language_response.h" +#include "application_manager/commands/hmi/vr_get_capabilities_request.h" +#include "application_manager/commands/hmi/vr_get_capabilities_response.h" +#include "application_manager/commands/hmi/tts_is_ready_request.h" +#include "application_manager/commands/hmi/tts_is_ready_response.h" +#include "application_manager/commands/hmi/tts_change_registration_request.h" +#include "application_manager/commands/hmi/tts_change_registration_response.h" +#include "application_manager/commands/hmi/tts_get_supported_languages_request.h" +#include "application_manager/commands/hmi/tts_get_supported_languages_response.h" +#include "application_manager/commands/hmi/tts_get_language_request.h" +#include "application_manager/commands/hmi/tts_get_language_response.h" +#include "application_manager/commands/hmi/tts_stop_speaking_request.h" +#include "application_manager/commands/hmi/tts_stop_speaking_response.h" +#include "application_manager/commands/hmi/tts_speak_request.h" +#include "application_manager/commands/hmi/tts_speak_response.h" +#include "application_manager/commands/hmi/tts_set_global_properties_request.h" +#include "application_manager/commands/hmi/tts_set_global_properties_response.h" +#include "application_manager/commands/hmi/tts_get_capabilities_request.h" +#include "application_manager/commands/hmi/tts_get_capabilities_response.h" +#include "application_manager/commands/hmi/vr_perform_interaction_request.h" +#include "application_manager/commands/hmi/vr_perform_interaction_response.h" +#include "application_manager/commands/hmi/vi_is_ready_request.h" +#include "application_manager/commands/hmi/vi_is_ready_response.h" +#include "application_manager/commands/hmi/vi_read_did_request.h" +#include "application_manager/commands/hmi/vi_read_did_response.h" +#include "application_manager/commands/hmi/sdl_activate_app_request.h" +#include "application_manager/commands/hmi/sdl_activate_app_response.h" +#include "application_manager/commands/hmi/on_app_permission_changed_notification.h" + +#ifdef HMI_DBUS_API +#include "application_manager/commands/hmi/vi_get_vehicle_data_request_template.h" +#include "application_manager/commands/hmi/vi_get_vehicle_data_response_template.h" +#include "application_manager/commands/hmi/vi_subscribe_vehicle_data_request_template.h" +#include "application_manager/commands/hmi/vi_subscribe_vehicle_data_response_template.h" +#include "application_manager/commands/hmi/vi_unsubscribe_vehicle_data_request_template.h" +#include "application_manager/commands/hmi/vi_unsubscribe_vehicle_data_response_template.h" +#include "application_manager/commands/hmi/on_vi_gps_data_notification.h" +#include "application_manager/commands/hmi/on_vi_speed_notification.h" +#include "application_manager/commands/hmi/on_vi_rpm_notification.h" +#include "application_manager/commands/hmi/on_vi_fuel_level_notification.h" +#include "application_manager/commands/hmi/on_vi_fuel_level_state_notification.h" +#include "application_manager/commands/hmi/on_vi_instant_fuel_consumption_notification.h" +#include "application_manager/commands/hmi/on_vi_external_temperature_notification.h" +#include "application_manager/commands/hmi/on_vi_vin_notification.h" +#include "application_manager/commands/hmi/on_vi_prndl_notification.h" +#include "application_manager/commands/hmi/on_vi_tire_pressure_notification.h" +#include "application_manager/commands/hmi/on_vi_odometer_notification.h" +#include "application_manager/commands/hmi/on_vi_belt_status_notification.h" +#include "application_manager/commands/hmi/on_vi_body_information_notification.h" +#include "application_manager/commands/hmi/on_vi_device_status_notification.h" +#include "application_manager/commands/hmi/on_vi_driver_braking_notification.h" +#include "application_manager/commands/hmi/on_vi_wiper_status_notification.h" +#include "application_manager/commands/hmi/on_vi_head_lamp_status_notification.h" +#include "application_manager/commands/hmi/on_vi_engine_torque_notification.h" +#include "application_manager/commands/hmi/on_vi_acc_pedal_position_notification.h" +#include "application_manager/commands/hmi/on_vi_steering_wheel_angle_notification.h" +#include "application_manager/commands/hmi/on_vi_my_key_notification.h" +#else +#include "application_manager/commands/hmi/vi_get_vehicle_data_request.h" +#include "application_manager/commands/hmi/vi_get_vehicle_data_response.h" +#include "application_manager/commands/hmi/on_vi_vehicle_data_notification.h" +#include "application_manager/commands/hmi/vi_subscribe_vehicle_data_request.h" +#include "application_manager/commands/hmi/vi_subscribe_vehicle_data_response.h" +#include "application_manager/commands/hmi/vi_unsubscribe_vehicle_data_request.h" +#include "application_manager/commands/hmi/vi_unsubscribe_vehicle_data_response.h" +#endif // #ifdef HMI_DBUS_API + +#include "application_manager/commands/hmi/vi_get_dtcs_request.h" +#include "application_manager/commands/hmi/vi_get_dtcs_response.h" +#include "application_manager/commands/hmi/vi_diagnostic_message_request.h" +#include "application_manager/commands/hmi/vi_diagnostic_message_response.h" +#include "application_manager/commands/hmi/vi_get_vehicle_type_request.h" +#include "application_manager/commands/hmi/vi_get_vehicle_type_response.h" +#include "application_manager/commands/hmi/navi_is_ready_request.h" +#include "application_manager/commands/hmi/navi_show_constant_tbt_request.h" +#include "application_manager/commands/hmi/navi_show_constant_tbt_response.h" +#include "application_manager/commands/hmi/navi_is_ready_response.h" +#include "application_manager/commands/hmi/navi_alert_maneuver_request.h" +#include "application_manager/commands/hmi/navi_alert_maneuver_response.h" +#include "application_manager/commands/hmi/navi_update_turn_list_request.h" +#include "application_manager/commands/hmi/navi_update_turn_list_response.h" +#include "application_manager/commands/hmi/on_ready_notification.h" +#include "application_manager/commands/hmi/on_device_chosen_notification.h" +#include "application_manager/commands/hmi/on_file_removed_notification.h" +#include "application_manager/commands/hmi/on_system_context_notification.h" +#include "application_manager/commands/hmi/on_app_registered_notification.h" +#include "application_manager/commands/hmi/on_app_unregistered_notification.h" +#include "application_manager/commands/hmi/on_driver_distraction_notification.h" +#include "application_manager/commands/hmi/on_play_tone_notification.h" +#include "application_manager/commands/hmi/on_tts_started_notification.h" +#include "application_manager/commands/hmi/on_tts_stopped_notification.h" +#include "application_manager/commands/hmi/on_vr_started_notification.h" +#include "application_manager/commands/hmi/on_vr_stopped_notification.h" +#include "application_manager/commands/hmi/on_vr_command_notification.h" +#include "application_manager/commands/hmi/on_ui_command_notification.h" +#include "application_manager/commands/hmi/on_app_deactivated_notification.h" +#include "application_manager/commands/hmi/on_ui_language_change_notification.h" +#include "application_manager/commands/hmi/on_vr_language_change_notification.h" +#include "application_manager/commands/hmi/on_tts_language_change_notification.h" +#include "application_manager/commands/hmi/on_navi_tbt_client_state_notification.h" +#include "application_manager/commands/hmi/on_button_event_notification.h" +#include "application_manager/commands/hmi/on_button_press_notification.h" +#include "application_manager/commands/hmi/on_vi_vehicle_data_notification.h" +#include "application_manager/commands/hmi/on_ui_keyboard_input_notification.h" +#include "application_manager/commands/hmi/on_ui_touch_event_notification.h" +#include "application_manager/commands/hmi/on_ui_reset_timeout_notification.h" +#include "application_manager/commands/hmi/navi_start_stream_request.h" +#include "application_manager/commands/hmi/navi_start_stream_response.h" +#include "application_manager/commands/hmi/navi_stop_stream_request.h" +#include "application_manager/commands/hmi/navi_stop_stream_response.h" +#include "application_manager/commands/hmi/navi_audio_start_stream_request.h" +#include "application_manager/commands/hmi/navi_audio_start_stream_response.h" +#include "application_manager/commands/hmi/navi_audio_stop_stream_request.h" +#include "application_manager/commands/hmi/navi_audio_stop_stream_response.h" +#include "application_manager/commands/hmi/on_system_request_notification.h" +#include "application_manager/commands/hmi/ui_set_display_layout_request.h" +#include "application_manager/commands/hmi/ui_set_display_layout_response.h" +#include "application_manager/commands/hmi/on_sdl_close_notification.h" +#include "application_manager/commands/hmi/on_sdl_persistence_complete_notification.h" +#include "application_manager/commands/hmi/on_record_start_notification.h" +#include "application_manager/commands/hmi/add_statistics_info_notification.h" +#include "application_manager/commands/hmi/on_system_error_notification.h" +#include "application_manager/commands/hmi/basic_communication_system_request.h" +#include "application_manager/commands/hmi/basic_communication_system_response.h" +#include "application_manager/commands/hmi/sdl_policy_update.h" +#include "application_manager/commands/hmi/sdl_policy_update_response.h" +#include "application_manager/commands/hmi/on_received_policy_update.h" +#include "application_manager/commands/hmi/on_policy_update.h" +#include "application_manager/commands/hmi/get_urls.h" +#include "application_manager/commands/hmi/get_urls_response.h" +#include "application_manager/commands/hmi/on_device_state_changed_notification.h" +#include "application_manager/commands/hmi/navi_send_location_request.h" +#include "application_manager/commands/hmi/navi_send_location_response.h" +#include "application_manager/commands/hmi/on_tts_reset_timeout_notification.h" + +namespace application_manager { + +CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager") + +CommandSharedPtr HMICommandFactory::CreateCommand( + const MessageSharedPtr& message) { + const int function_id = (*message)[strings::params][strings::function_id] + .asInt(); + LOG4CXX_INFO(logger_, + "HMICommandFactory::CreateCommand function_id: " << function_id); + + CommandSharedPtr command( + new application_manager::commands::CommandImpl(message)); + + bool is_response = false; + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + is_response = true; + LOG4CXX_INFO(logger_, "HMICommandFactory::CreateCommand response"); + } else if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kErrorResponse)) { + is_response = true; + LOG4CXX_INFO(logger_, "HMICommandFactory::CreateCommand error response"); + } else { + LOG4CXX_INFO(logger_, "HMICommandFactory::CreateCommand request"); + } + + switch (function_id) { + case hmi_apis::FunctionID::BasicCommunication_OnStartDeviceDiscovery: { + command.reset(new commands::OnStartDeviceDiscovery(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_UpdateDeviceList: { + if (is_response) { + command.reset(new commands::UpdateDeviceListResponse(message)); + } else { + command.reset(new commands::UpdateDeviceListRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_ActivateApp: { + if (is_response) { + command.reset(new commands::ActivateAppResponse(message)); + } else { + command.reset(new commands::ActivateAppRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_GetSystemInfo: { + if (is_response) { + command.reset(new commands::GetSystemInfoResponse(message)); + } else { + command.reset(new commands::GetSystemInfoRequest(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_ActivateApp: { + if (is_response) { + command.reset(new commands::SDLActivateAppResponse(message)); + } else { + command.reset(new commands::SDLActivateAppRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_PolicyUpdate: { + if (is_response) { + command.reset(new commands::SDLPolicyUpdateResponse(message)); + } else { + command.reset(new commands::SDLPolicyUpdate(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_GetURLS: { + if (is_response) { + command.reset(new commands::GetUrlsResponse(message)); + } else { + command.reset(new commands::GetUrls(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_OnAppPermissionChanged: { + command.reset(new commands::OnAppPermissionChangedNotification(message)); + break; + } + case hmi_apis::FunctionID::SDL_GetListOfPermissions: { + if (is_response) { + command.reset(new commands::SDLGetListOfPermissionsResponse(message)); + } else { + command.reset(new commands::SDLGetListOfPermissionsRequest(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_GetUserFriendlyMessage: { + if (is_response) { + command.reset(new commands::SDLGetUserFriendlyMessageResponse(message)); + } else { + command.reset(new commands::SDLGetUserFriendlyMessageRequest(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_GetStatusUpdate: { + if (is_response) { + command.reset(new commands::SDLGetStatusUpdateResponse(message)); + } else { + command.reset(new commands::SDLGetStatusUpdateRequest(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_OnStatusUpdate: { + command.reset(new commands::OnStatusUpdateNotification(message)); + break; + } + case hmi_apis::FunctionID::SDL_OnAppPermissionConsent: { + command.reset(new commands::OnAppPermissionConsentNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_MixingAudioSupported: { + if (is_response) { + command.reset(new commands::MixingAudioSupportedResponse(message)); + } else { + command.reset(new commands::MixingAudioSupportedRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnExitAllApplications: { + command.reset(new commands::OnExitAllApplicationsNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_AddCommand: { + if (is_response) { + command.reset(new commands::UIAddCommandResponse(message)); + } else { + command.reset(new commands::UIAddCommandRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_DeleteCommand: { + if (is_response) { + command.reset(new commands::UIDeleteCommandResponse(message)); + } else { + command.reset(new commands::UIDeleteCommandRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_AddSubMenu: { + if (is_response) { + command.reset(new commands::UIAddSubmenuResponse(message)); + } else { + command.reset(new commands::UIAddSubmenuRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_DeleteSubMenu: { + if (is_response) { + command.reset(new commands::UIDeleteSubmenuResponse(message)); + } else { + command.reset(new commands::UIDeleteSubmenuRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_SetMediaClockTimer: { + if (is_response) { + command.reset(new commands::UISetMediaClockTimerResponse(message)); + } else { + command.reset(new commands::UISetMediaClockTimerRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_PerformInteraction: { + if (is_response) { + command.reset(new commands::UIPerformInteractionResponse(message)); + } else { + command.reset(new commands::UIPerformInteractionRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_SetGlobalProperties: { + if (is_response) { + command.reset(new commands::UISetGlobalPropertiesResponse(message)); + } else { + command.reset(new commands::UISetGlobalPropertiesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_ScrollableMessage: { + if (is_response) { + command.reset(new commands::UIScrollableMessageResponse(message)); + } else { + command.reset(new commands::UIScrollableMessageRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_SetAppIcon: { + if (is_response) { + command.reset(new commands::UISetIconResponse(message)); + } else { + command.reset(new commands::UISetIconRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_GetSupportedLanguages: { + if (is_response) { + command.reset(new commands::UIGetSupportedLanguagesResponse(message)); + } else { + command.reset(new commands::UIGetSupportedLanguagesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_GetLanguage: { + if (is_response) { + command.reset(new commands::UIGetLanguageResponse(message)); + } else { + command.reset(new commands::UIGetLanguageRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_GetCapabilities: { + if (is_response) { + command.reset(new commands::UIGetCapabilitiesResponse(message)); + } else { + command.reset(new commands::UIGetCapabilitiesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_ChangeRegistration: { + if (is_response) { + command.reset(new commands::UIChangeRegistratioResponse(message)); + } else { + command.reset(new commands::UIChangeRegistrationRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_PerformAudioPassThru: { + if (is_response) { + command.reset(new commands::UIPerformAudioPassThruResponse(message)); + } else { + command.reset(new commands::UIPerformAudioPassThruRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_EndAudioPassThru: { + if (is_response) { + command.reset(new commands::UIEndAudioPassThruResponse(message)); + } else { + command.reset(new commands::UIEndAudioPassThruRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_Alert: { + if (is_response) { + command.reset(new commands::UIAlertResponse(message)); + } else { + command.reset(new commands::UIAlertRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_IsReady: { + if (is_response) { + command.reset(new commands::VRIsReadyResponse(message)); + } else { + command.reset(new commands::VRIsReadyRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_AddCommand: { + if (is_response) { + command.reset(new commands::VRAddCommandResponse(message)); + } else { + command.reset(new commands::VRAddCommandRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_DeleteCommand: { + if (is_response) { + command.reset(new commands::VRDeleteCommandResponse(message)); + } else { + command.reset(new commands::VRDeleteCommandRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_ChangeRegistration: { + if (is_response) { + command.reset(new commands::VRChangeRegistrationResponse(message)); + } else { + command.reset(new commands::VRChangeRegistrationRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_GetSupportedLanguages: { + if (is_response) { + command.reset(new commands::VRGetSupportedLanguagesResponse(message)); + } else { + command.reset(new commands::VRGetSupportedLanguagesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_GetLanguage: { + if (is_response) { + command.reset(new commands::VRGetLanguageResponse(message)); + } else { + command.reset(new commands::VRGetLanguageRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_GetCapabilities: { + if (is_response) { + command.reset(new commands::VRGetCapabilitiesResponse(message)); + } else { + command.reset(new commands::VRGetCapabilitiesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_IsReady: { + if (is_response) { + command.reset(new commands::TTSIsReadyResponse(message)); + } else { + command.reset(new commands::TTSIsReadyRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_ChangeRegistration: { + if (is_response) { + command.reset(new commands::TTSChangeRegistratioResponse(message)); + } else { + command.reset(new commands::TTSChangeRegistrationRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_GetSupportedLanguages: { + if (is_response) { + command.reset(new commands::TTSGetSupportedLanguagesResponse(message)); + } else { + command.reset(new commands::TTSGetSupportedLanguagesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_StopSpeaking: { + if (is_response) { + command.reset(new commands::TTSStopSpeakingResponse(message)); + } else { + command.reset(new commands::TTSStopSpeakingRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_GetLanguage: { + if (is_response) { + command.reset(new commands::TTSGetLanguageResponse(message)); + } else { + command.reset(new commands::TTSGetLanguageRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_Speak: { + if (is_response) { + command.reset(new commands::TTSSpeakResponse(message)); + } else { + command.reset(new commands::TTSSpeakRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_SetGlobalProperties: { + if (is_response) { + command.reset(new commands::TTSSetGlobalPropertiesResponse(message)); + } else { + command.reset(new commands::TTSSetGlobalPropertiesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_GetCapabilities: { + if (is_response) { + command.reset(new commands::TTSGetCapabilitiesResponse(message)); + } else { + command.reset(new commands::TTSGetCapabilitiesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::TTS_Started: { + command.reset(new commands::OnTTSStartedNotification(message)); + break; + } + case hmi_apis::FunctionID::TTS_Stopped: { + command.reset(new commands::OnTTSStoppedNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnAppActivated: { + command.reset(new commands::OnAppActivatedNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnExitApplication: { + command.reset(new commands::OnExitApplicationNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_Show: { + if (is_response) { + command.reset(new commands::UIShowResponse(message)); + } else { + command.reset(new commands::UIShowRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_Slider: { + if (is_response) { + command.reset(new commands::UISliderResponse(message)); + } else { + command.reset(new commands::UISliderRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_ClosePopUp: { + if (is_response) { + command.reset(new commands::ClosePopupResponse(message)); + } else { + command.reset(new commands::ClosePopupRequest(message)); + } + break; + } + case hmi_apis::FunctionID::UI_IsReady: { + if (is_response) { + command.reset(new commands::UIIsReadyResponse(message)); + } else { + command.reset(new commands::UIIsReadyRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VehicleInfo_IsReady: { + if (is_response) { + command.reset(new commands::VIIsReadyResponse(message)); + } else { + command.reset(new commands::VIIsReadyRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VehicleInfo_ReadDID: { + if (is_response) { + command.reset(new commands::VIReadDIDResponse(message)); + } else { + command.reset(new commands::VIReadDIDRequest(message)); + } + break; + } +#ifdef HMI_DBUS_API + case hmi_apis::FunctionID::VehicleInfo_GetGpsData: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetGpsData > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetGpsData > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetSpeed: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetSpeed > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetSpeed > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetRpm: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetRpm > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetRpm > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetFuelLevel: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetFuelLevel > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetFuelLevel > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetFuelLevelState: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetFuelLevelState > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetFuelLevelState > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetInstantFuelConsumption: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetInstantFuelConsumption > ( + message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetInstantFuelConsumption > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetExternalTemperature: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetExternalTemperature > ( + message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetExternalTemperature > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetPrndl: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetPrndl > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetPrndl > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetVin: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetVin > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetVin > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetTirePressure: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetTirePressure > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetTirePressure > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetOdometer: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetOdometer > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetOdometer > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetBeltStatus: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetBeltStatus > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetBeltStatus > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetBodyInformation: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetBodyInformation > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetBodyInformation > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetDeviceStatus: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetDeviceStatus > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetDeviceStatus > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetDriverBraking: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetDriverBraking > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetDriverBraking > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetWiperStatus: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetWiperStatus > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetWiperStatus > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetHeadLampStatus: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetHeadLampStatus > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetHeadLampStatus > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetEngineTorque: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetEngineTorque > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetEngineTorque > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetAccPedalPosition: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetAccPedalPosition > ( + message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetAccPedalPosition > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetSteeringWheelAngle: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetSteeringWheelAngle > ( + message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetSteeringWheelAngle > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetECallInfo: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetECallInfo > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetECallInfo > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetAirbagStatus: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetAirbagStatus > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetAirbagStatus > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetEmergencyEvent: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetEmergencyEvent > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetEmergencyEvent > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetClusterModeStatus: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetClusterModeStatus > ( + message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetClusterModeStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetMyKey: { + if (is_response) + command.reset( + new commands::VIGetVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_GetMyKey > (message)); + else + command.reset( + new commands::VIGetVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_GetMyKey > (message)); + break; + } +#else + case hmi_apis::FunctionID::VehicleInfo_GetVehicleData: { + if (is_response) { + command.reset(new commands::VIGetVehicleDataResponse(message)); + } else { + command.reset(new commands::VIGetVehicleDataRequest(message)); + } + break; + } +#endif // #ifdef HMI_DBUS_API + case hmi_apis::FunctionID::VehicleInfo_GetDTCs: { + if (is_response) { + command.reset(new commands::VIGetDTCsResponse(message)); + } else { + command.reset(new commands::VIGetDTCsRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VehicleInfo_DiagnosticMessage: { + if (is_response) { + command.reset(new commands::VIDiagnosticMessageResponse(message)); + } else { + command.reset(new commands::VIDiagnosticMessageRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VehicleInfo_GetVehicleType: { + if (is_response) { + command.reset(new commands::VIGetVehicleTypeResponse(message)); + } else { + command.reset(new commands::VIGetVehicleTypeRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_IsReady: { + if (is_response) { + command.reset(new commands::NaviIsReadyResponse(message)); + } else { + command.reset(new commands::NaviIsReadyRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_AlertManeuver: { + if (is_response) { + command.reset(new commands::NaviAlertManeuverResponse(message)); + } else { + command.reset(new commands::NaviAlertManeuverRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_UpdateTurnList: { + if (is_response) { + command.reset(new commands::NaviUpdateTurnListResponse(message)); + } else { + command.reset(new commands::NaviUpdateTurnListRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_ShowConstantTBT: { + if (is_response) { + command.reset(new commands::NaviShowConstantTBTResponse(message)); + } else { + command.reset(new commands::NaviShowConstantTBTRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Buttons_GetCapabilities: { + if (is_response) { + command.reset(new commands::ButtonGetCapabilitiesResponse(message)); + } else { + command.reset(new commands::ButtonGetCapabilitiesRequest(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_OnAllowSDLFunctionality: { + command.reset(new commands::OnAllowSDLFunctionalityNotification(message)); + break; + } + case hmi_apis::FunctionID::SDL_OnSDLConsentNeeded: { + command.reset(new commands::OnSDLConsentNeededNotification(message)); + break; + } + case hmi_apis::FunctionID::SDL_UpdateSDL: { + if (is_response) { + command.reset(new commands::UpdateSDLResponse(message)); + } else { + command.reset(new commands::UpdateSDLRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnIgnitionCycleOver: { + command.reset(new commands::OnIgnitionCycleOverNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnSystemInfoChanged: { + command.reset(new commands::OnSystemInfoChangedNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_PlayTone: { + command.reset(new commands::OnPlayToneNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnReady: { + command.reset(new commands::OnReadyNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnDeviceChosen: { + command.reset(new commands::OnDeviceChosenNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnSystemContext: { + command.reset(new commands::OnSystemContextNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnDriverDistraction: { + command.reset( + new commands::hmi::OnDriverDistractionNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnUpdateDeviceList: { + command.reset(new commands::OnUpdateDeviceList(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnAppRegistered: { + command.reset(new commands::OnAppRegisteredNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnAppUnregistered: { + command.reset(new commands::OnAppUnregisteredNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnFindApplications: { + command.reset(new commands::OnFindApplications(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_UpdateAppList: { + if (is_response) { + command.reset(new commands::UpdateAppListResponse(message)); + } else { + command.reset(new commands::UpdateAppListRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_Started: { + command.reset(new commands::OnVRStartedNotification(message)); + break; + } + case hmi_apis::FunctionID::VR_Stopped: { + command.reset(new commands::OnVRStoppedNotification(message)); + break; + } + case hmi_apis::FunctionID::VR_OnCommand: { + command.reset(new commands::OnVRCommandNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnCommand: { + command.reset(new commands::OnUICommandNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnAppDeactivated: { + command.reset(new commands::OnAppDeactivatedNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnLanguageChange: { + command.reset(new commands::OnUILanguageChangeNotification(message)); + break; + } + case hmi_apis::FunctionID::VR_OnLanguageChange: { + command.reset(new commands::OnVRLanguageChangeNotification(message)); + break; + } + case hmi_apis::FunctionID::TTS_OnLanguageChange: { + command.reset(new commands::OnTTSLanguageChangeNotification(message)); + break; + } + case hmi_apis::FunctionID::Buttons_OnButtonEvent: { + command.reset(new commands::hmi::OnButtonEventNotification(message)); + break; + } + case hmi_apis::FunctionID::Buttons_OnButtonPress: { + command.reset(new commands::hmi::OnButtonPressNotification(message)); + break; + } +#ifdef HMI_DBUS_API + case hmi_apis::FunctionID::VehicleInfo_SubscribeGps: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeGps > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeGps > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeSpeed: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeSpeed > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeSpeed > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeRpm: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeRpm > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeRpm > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel_State: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel_State > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel_State > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeInstantFuelConsumption: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeInstantFuelConsumption > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeInstantFuelConsumption > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeExternalTemperature: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeExternalTemperature > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeExternalTemperature > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribePrndl: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribePrndl > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribePrndl > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeVin: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeVin > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeVin > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeTirePressure: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeTirePressure > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeTirePressure > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeOdometer: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeOdometer > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeOdometer > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeBeltStatus: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeBeltStatus > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeBeltStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeBodyInformation: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeBodyInformation > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeBodyInformation > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeDeviceStatus: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeDeviceStatus > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeDeviceStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeDriverBraking: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeDriverBraking > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeDriverBraking > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeWiperStatus: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeWiperStatus > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeWiperStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeHeadLampStatus: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeHeadLampStatus > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeHeadLampStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeEngineTorque: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeEngineTorque > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeEngineTorque > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeAccPedalPosition: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeAccPedalPosition > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeAccPedalPosition > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeSteeringWheelAngle: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeSteeringWheelAngle > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeSteeringWheelAngle > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeECallInfo: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeECallInfo > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeECallInfo > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeAirbagStatus: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeAirbagStatus > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeAirbagStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeEmergencyEvent: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeEmergencyEvent > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeEmergencyEvent > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeClusterModeStatus: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeClusterModeStatus > ( + message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeClusterModeStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_SubscribeMyKey: { + if (is_response) + command.reset( + new commands::VISubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeMyKey > (message)); + else + command.reset( + new commands::VISubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_SubscribeMyKey > (message)); + break; + } +#else + case hmi_apis::FunctionID::VehicleInfo_SubscribeVehicleData: { + if (is_response) { + command.reset(new commands::VISubscribeVehicleDataResponse(message)); + } else { + command.reset(new commands::VISubscribeVehicleDataRequest(message)); + } + break; + } +#endif // #ifdef HMI_DBUS_API +#ifdef HMI_DBUS_API + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeGps: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeGps > (message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeGps > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeSpeed: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeSpeed > (message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeSpeed > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeRpm: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeRpm > (message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeRpm > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel_State: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel_State > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeFuelLevel_State > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeInstantFuelConsumption: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeInstantFuelConsumption > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeInstantFuelConsumption > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeExternalTemperature: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeExternalTemperature > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeExternalTemperature > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribePrndl: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribePrndl > (message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribePrndl > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeVin: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeVin > (message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeVin > (message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeTirePressure: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeTirePressure > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeTirePressure > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeOdometer: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeOdometer > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeOdometer > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeBeltStatus: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeBeltStatus > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeBeltStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeBodyInformation: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeBodyInformation > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeBodyInformation > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeDeviceStatus: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeDeviceStatus > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeDeviceStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeDriverBraking: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeDriverBraking > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeDriverBraking > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeWiperStatus: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeWiperStatus > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeWiperStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeHeadLampStatus: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeHeadLampStatus > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeHeadLampStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeEngineTorque: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeEngineTorque > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeEngineTorque > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeAccPedalPosition: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeAccPedalPosition > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeAccPedalPosition > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeSteeringWheelAngle: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeSteeringWheelAngle > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeSteeringWheelAngle > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeECallInfo: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeECallInfo > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeECallInfo > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeAirbagStatus: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeAirbagStatus > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeAirbagStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeEmergencyEvent: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeEmergencyEvent > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeEmergencyEvent > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeClusterModeStatus: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeClusterModeStatus > ( + message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeClusterModeStatus > ( + message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeMyKey: { + if (is_response) + command.reset( + new commands::VIUnsubscribeVehicleDataResponseTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeMyKey > (message)); + else + command.reset( + new commands::VIUnsubscribeVehicleDataRequestTemplate < + hmi_apis::FunctionID::VehicleInfo_UnsubscribeMyKey > (message)); + break; + } +#else + case hmi_apis::FunctionID::VehicleInfo_UnsubscribeVehicleData: { + if (is_response) { + command.reset(new commands::VIUnsubscribeVehicleDataResponse(message)); + } else { + command.reset(new commands::VIUnsubscribeVehicleDataRequest(message)); + } + break; + } +#endif // #ifdef HMI_DBUS_API +#ifdef HMI_DBUS_API + case hmi_apis::FunctionID::VehicleInfo_OnGpsData: { + command.reset(new commands::OnVIGpsDataNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnSpeed: { + command.reset(new commands::OnVISpeedNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnRpm: { + command.reset(new commands::OnVIRpmNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnFuelLevel: { + command.reset(new commands::OnVIFuelLevelNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnFuelLevelState: { + command.reset(new commands::OnVIFuelLevelStateNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnInstantFuelConsumption: { + command.reset( + new commands::OnVIInstantFuelConsumptionNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnExternalTemperature: { + command.reset(new commands::OnVIExternalTemperatureNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnVin: { + command.reset(new commands::OnVIVinNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnPrndl: { + command.reset(new commands::OnVIPrndlNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnTirePressure: { + command.reset(new commands::OnVITirePressureNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnOdometer: { + command.reset(new commands::OnVIOdometerNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnBeltStatus: { + command.reset(new commands::OnVIBeltStatusNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnBodyInformation: { + command.reset(new commands::OnVIBodyInformationNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnDeviceStatus: { + command.reset(new commands::OnVIDeviceStatusNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnDriverBraking: { + command.reset(new commands::OnVIDriverBrakingNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnWiperStatus: { + command.reset(new commands::OnVIWiperStatusNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnHeadLampStatus: { + command.reset(new commands::OnVIHeadLampStatusNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnEngineTorque: { + command.reset(new commands::OnVIEngineTorqueNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnAccPedalPosition: { + command.reset(new commands::OnVIAccPedalPositionNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnSteeringWheelAngle: { + command.reset(new commands::OnVISteeringWheelAngleNotification(message)); + break; + } + case hmi_apis::FunctionID::VehicleInfo_OnMyKey: { + command.reset(new commands::OnVIMyKeyNotification(message)); + break; + } +#else + case hmi_apis::FunctionID::VehicleInfo_OnVehicleData: { + command.reset(new commands::OnVIVehicleDataNotification(message)); + break; + } +#endif // #ifdef HMI_DBUS_API + case hmi_apis::FunctionID::Navigation_OnTBTClientState: { + command.reset(new commands::OnNaviTBTClientStateNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnKeyboardInput: { + command.reset(new commands::hmi::OnUIKeyBoardInputNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnTouchEvent: { + command.reset(new commands::hmi::OnUITouchEventNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnResetTimeout: { + command.reset(new commands::hmi::OnUIResetTimeoutNotification(message)); + break; + } + case hmi_apis::FunctionID::Navigation_StartStream: { + if (is_response) { + command.reset(new commands::NaviStartStreamResponse(message)); + } else { + command.reset(new commands::NaviStartStreamRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_StopStream: { + if (is_response) { + command.reset(new commands::NaviStopStreamResponse(message)); + } else { + command.reset(new commands::NaviStopStreamRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_StartAudioStream: { + if (is_response) { + command.reset(new commands::AudioStartStreamResponse(message)); + } else { + command.reset(new commands::AudioStartStreamRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_StopAudioStream: { + if (is_response) { + command.reset(new commands::AudioStopStreamResponse(message)); + } else { + command.reset(new commands::AudioStopStreamRequest(message)); + } + break; + } + case hmi_apis::FunctionID::VR_PerformInteraction: { + if (is_response) { + command.reset(new commands::VRPerformInteractionResponse(message)); + } else { + command.reset(new commands::VRPerformInteractionRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnSystemRequest: { + command.reset(new commands::OnSystemRequestNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnPutFile: { + command.reset(new commands::OnPutFileNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnResumeAudioSource: { + command.reset(new commands::OnResumeAudioSourceNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_SetDisplayLayout: { + if (is_response) { + command.reset(new commands::UiSetDisplayLayoutResponse(message)); + } else { + command.reset(new commands::UiSetDisplayLayoutRequest(message)); + } + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnSDLClose: { + command.reset(new commands::OnSDLCloseNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnSDLPersistenceComplete: { + command.reset(new commands::OnSDLPersistenceCompleteNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnFileRemoved: { + command.reset(new commands::OnFileRemovedNotification(message)); + break; + } + case hmi_apis::FunctionID::UI_OnRecordStart: { + command.reset(new commands::OnRecordStartdNotification(message)); + break; + } + case hmi_apis::FunctionID::BasicCommunication_SystemRequest: { + if (is_response) { + command.reset(new commands::BasicCommunicationSystemResponse(message)); + } else { + command.reset(new commands::BasicCommunicationSystemRequest(message)); + } + break; + } + case hmi_apis::FunctionID::Navigation_SendLocation: { + if (is_response) { + command.reset(new commands::NaviSendLocationResponse(message)); + } else { + command.reset(new commands::NaviSendLocationRequest(message)); + } + break; + } + case hmi_apis::FunctionID::SDL_AddStatisticsInfo: { + command.reset(new commands::AddStatisticsInfoNotification(message)); + break; + } + case hmi_apis::FunctionID::SDL_OnSystemError: { + command.reset(new commands::OnSystemErrorNotification(message)); + break; + } + case hmi_apis::FunctionID::SDL_OnReceivedPolicyUpdate: { + command.reset(new commands::OnReceivedPolicyUpdate(message)); + break; + } + case hmi_apis::FunctionID::SDL_OnPolicyUpdate: { + command.reset(new commands::OnPolicyUpdate(message)); + break; + } + case hmi_apis::FunctionID::SDL_OnDeviceStateChanged: { + command.reset(new commands::OnDeviceStateChangedNotification(message)); + break; + } + case hmi_apis::FunctionID::TTS_OnResetTimeout: { + command.reset(new commands::hmi::OnTTSResetTimeoutNotification(message)); + break; + } + } + + return command; +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/message.cc b/src/components/application_manager/src/message.cc new file mode 100644 index 0000000000..832016e874 --- /dev/null +++ b/src/components/application_manager/src/message.cc @@ -0,0 +1,209 @@ +/** + * Copyright (c) 2013, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/message.h" + +namespace { +bool BinaryDataPredicate(uint8_t i, uint8_t j) { + return (i == j); +} +} + +namespace application_manager { + +MessageType MessageTypeFromRpcType(protocol_handler::RpcType rpc_type) { + switch (rpc_type) { + case protocol_handler::kRpcTypeRequest: + return kRequest; + case protocol_handler::kRpcTypeResponse: + return kResponse; + case protocol_handler::kRpcTypeNotification: + return kNotification; + case protocol_handler::kRpcTypeReserved: + default: + DCHECK(false); + return kUnknownType; + } +} + +Message::Message(protocol_handler::MessagePriority priority) + : function_id_(0), + correlation_id_(0), + type_(kUnknownType), + priority_(priority), + connection_key_(0), + binary_data_(NULL), + data_size_(0), + payload_size_(0), + version_(kUnknownProtocol) { +} + +Message::Message(const Message& message) + : priority_(message.priority_) { + *this = message; +} + +Message& Message::operator=(const Message& message) { + set_function_id(message.function_id_); + set_correlation_id(message.correlation_id_); + set_connection_key(message.connection_key_); + set_message_type(message.type_); + set_data_size(message.data_size_); + set_payload_size(message.payload_size_); + if (message.binary_data_) { + set_binary_data(message.binary_data_); + } + set_json_message(message.json_message_); + set_protocol_version(message.protocol_version()); + priority_ = message.priority_; + + return *this; +} + +bool Message::operator==(const Message& message) { + bool function_id = function_id_ == message.function_id_; + bool correlation_id = correlation_id_ == message.correlation_id_; + bool connection_key = connection_key_ == message.connection_key_; + bool type = type_ == message.type_; + bool json_message = json_message_ == message.json_message_; + bool version = version_ == message.version_; + bool data_size = data_size_ == message.data_size_; + bool payload_size = payload_size_ == message.payload_size_; + + + bool binary_data = std::equal(binary_data_->begin(), binary_data_->end(), + message.binary_data_->begin(), + BinaryDataPredicate); + + return function_id && correlation_id && connection_key && type && binary_data + && json_message && version && data_size && payload_size; +} + +Message::~Message() { + if (binary_data_) { + delete binary_data_; + } +} + +int32_t Message::function_id() const { + return function_id_; +} + +int32_t Message::correlation_id() const { + return correlation_id_; +} + +int32_t Message::connection_key() const { + return connection_key_; +} + +MessageType Message::type() const { + return type_; +} + +ProtocolVersion Message::protocol_version() const { + return version_; +} + +const std::string& Message::json_message() const { + return json_message_; +} + +const BinaryData* Message::binary_data() const { + return binary_data_; +} + +bool Message::has_binary_data() const { + return (binary_data_ != NULL); +} + +size_t Message::data_size() const { + return data_size_; +} + +size_t Message::payload_size() const { + return payload_size_; +} + +void Message::set_function_id(int32_t id) { + function_id_ = id; +} + +void Message::set_correlation_id(int32_t id) { + correlation_id_ = id; +} + +void Message::set_connection_key(int32_t key) { + connection_key_ = key; +} + +void Message::set_message_type(MessageType type) { + type_ = type; +} + +void Message::set_binary_data(BinaryData* data) { + if (NULL == data) { + NOTREACHED(); + return; + } + + if (binary_data_) { + delete binary_data_; + } + + binary_data_ = data; +} + +void Message::set_json_message(const std::string& json_message) { + json_message_ = json_message; +} + +void Message::set_protocol_version(ProtocolVersion version) { + version_ = version; +} + +const smart_objects::SmartObject &Message::smart_object() const { + return smart_object_; +} + +void Message::set_smart_object(const smart_objects::SmartObject& object) { + smart_object_ = object; +} + +void Message::set_data_size(size_t data_size) { + data_size_ = data_size; +} + +void Message::set_payload_size(size_t payload_size) { + payload_size_ = payload_size; +} +} // namespace application_manager diff --git a/src/components/application_manager/src/message_helper.cc b/src/components/application_manager/src/message_helper.cc new file mode 100644 index 0000000000..b97b01c0d6 --- /dev/null +++ b/src/components/application_manager/src/message_helper.cc @@ -0,0 +1,2357 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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. + */ + +#define __STDC_FORMAT_MACROS +#include <inttypes.h> +#undef __STDC_FORMAT_MACROS + +#include <set> +#include <string> +#include <algorithm> +#include <utility> +#include <map> + +#include "application_manager/application.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/commands/command_impl.h" +#include "application_manager/message_helper.h" +#include "application_manager/policies/policy_handler.h" +#include "config_profile/profile.h" +#include "connection_handler/connection_handler_impl.h" +#include "interfaces/MOBILE_API.h" +#include "smart_objects/enum_schema_item.h" +#include "utils/file_system.h" +#include "utils/macro.h" +#include "utils/logger.h" + +namespace application_manager { + +CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager") + +namespace { + +hmi_apis::Common_Language::eType ToCommonLanguage( + mobile_apis::Language::eType mobile_language) { + // Update this check if mobile_api::Language + // or hmi_apis::Common_Language changes. + // Or, better, generate functions like this from XML + long lang_val = long(mobile_language); + long max_common_lang_val = long(hmi_apis::Common_Language::NO_NO); + long max_mobile_lang = long(mobile_apis::Language::NO_NO); + if (max_common_lang_val != max_mobile_lang) { + LOG4CXX_ERROR(logger_, "Mapping between Common_Language and Language" + " has changed! Please update converter function"); + } + if (lang_val > max_common_lang_val) { + LOG4CXX_ERROR(logger_, "Non-convertable language ID"); + } + return hmi_apis::Common_Language::eType(lang_val); +} + +typedef +std::map<std::string, hmi_apis::Common_AppPriority::eType> CommonAppPriorityMap; + +CommonAppPriorityMap app_priority_values = { + {"NORMAL", hmi_apis::Common_AppPriority::NORMAL}, + {"COMMUNICATION", hmi_apis::Common_AppPriority::COMMUNICATION}, + {"EMERGENCY", hmi_apis::Common_AppPriority::EMERGENCY}, + {"NAVIGATION", hmi_apis::Common_AppPriority::NAVIGATION}, + {"NONE", hmi_apis::Common_AppPriority::NONE}, + {"VOICECOM", hmi_apis::Common_AppPriority::VOICE_COMMUNICATION}, + {"INVALID_ENUM", hmi_apis::Common_AppPriority::INVALID_ENUM} +}; + +const uint32_t GetPriorityCode(const std::string& priority) { + CommonAppPriorityMap::const_iterator it = app_priority_values.find(priority); + if (app_priority_values.end() != it) { + return static_cast<uint32_t>((*it).second); + } + return static_cast<uint32_t>(hmi_apis::Common_AppPriority::INVALID_ENUM); +} + +bool ValidateSoftButtons(smart_objects::SmartObject& soft_buttons) { + using namespace smart_objects; + for (size_t i = 0; i < soft_buttons.length(); ++i) { + SmartObject& button = soft_buttons[i]; + + // Check if image parameter is valid + if (button.keyExists(strings::image)) { + SmartObject& buttonImage = button[strings::image]; + + // Image name must not be empty and must not contain incorrect + //character + if (false == MessageHelper::VerifySoftButtonString( + buttonImage[strings::value].asString())) { + return false; + } + } + } + return true; +} // namespace + +} +std::pair<std::string, VehicleDataType> kVehicleDataInitializer[] = { + std::make_pair(strings::gps, VehicleDataType::GPS), std::make_pair( + strings::speed, VehicleDataType::SPEED), std::make_pair( + strings::rpm, VehicleDataType::RPM), std::make_pair( + strings::fuel_level, VehicleDataType::FUELLEVEL), std::make_pair( + strings::fuel_level_state, VehicleDataType::FUELLEVEL_STATE), + std::make_pair(strings::instant_fuel_consumption, + VehicleDataType::FUELCONSUMPTION), std::make_pair( + strings::external_temp, VehicleDataType::EXTERNTEMP), std::make_pair( + strings::vin, VehicleDataType::VIN), std::make_pair( + strings::prndl, VehicleDataType::PRNDL), std::make_pair( + strings::tire_pressure, VehicleDataType::TIREPRESSURE), std::make_pair( + strings::odometer, VehicleDataType::ODOMETER), std::make_pair( + strings::belt_status, VehicleDataType::BELTSTATUS), std::make_pair( + strings::body_information, VehicleDataType::BODYINFO), std::make_pair( + strings::device_status, VehicleDataType::DEVICESTATUS), std::make_pair( + strings::driver_braking, VehicleDataType::BRAKING), std::make_pair( + strings::wiper_status, VehicleDataType::WIPERSTATUS), std::make_pair( + strings::head_lamp_status, VehicleDataType::HEADLAMPSTATUS), + std::make_pair(strings::e_call_info, VehicleDataType::ECALLINFO), + std::make_pair(strings::airbag_status, VehicleDataType::AIRBAGSTATUS), + std::make_pair(strings::emergency_event, VehicleDataType::EMERGENCYEVENT), + std::make_pair(strings::cluster_mode_status, + VehicleDataType::CLUSTERMODESTATUS), std::make_pair( + strings::my_key, VehicleDataType::MYKEY), + /* + NOT DEFINED in mobile API + std::make_pair(strings::gps, VehicleDataType::BATTVOLTAGE), + */ + std::make_pair(strings::engine_torque, VehicleDataType::ENGINETORQUE), + std::make_pair(strings::acc_pedal_pos, VehicleDataType::ACCPEDAL), + std::make_pair(strings::steering_wheel_angle, + VehicleDataType::STEERINGWHEEL), +}; + +const VehicleData MessageHelper::vehicle_data_( + kVehicleDataInitializer, kVehicleDataInitializer + + ARRAYSIZE(kVehicleDataInitializer)); + +#ifdef HMI_DBUS_API +namespace { +struct VehicleInfo_Requests { + hmi_apis::FunctionID::eType func_id; + const char* str; +}; +static VehicleInfo_Requests ivi_subrequests[] = { + { hmi_apis::FunctionID::VehicleInfo_SubscribeGps, strings::gps}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeSpeed, strings::speed}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeRpm, strings::rpm}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel, strings::fuel_level}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeFuelLevel_State, strings::fuel_level_state}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeInstantFuelConsumption, strings::instant_fuel_consumption}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeExternalTemperature, strings::external_temp}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeVin, strings::vin}, + { hmi_apis::FunctionID::VehicleInfo_SubscribePrndl, strings::prndl}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeTirePressure, strings::tire_pressure}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeOdometer, strings::odometer}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeBeltStatus, strings::belt_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeBodyInformation, strings::body_information}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeDeviceStatus, strings::device_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeDriverBraking, strings::driver_braking}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeWiperStatus, strings::wiper_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeHeadLampStatus, strings::head_lamp_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeEngineTorque, strings::engine_torque}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeAccPedalPosition, strings::acc_pedal_pos}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeSteeringWheelAngle, strings::steering_wheel_angle}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeECallInfo, strings::e_call_info}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeAirbagStatus, strings::airbag_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeEmergencyEvent, strings::emergency_event}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeClusterModeStatus, strings::cluster_mode_status}, + { hmi_apis::FunctionID::VehicleInfo_SubscribeMyKey, strings::my_key}, +}; +} +#endif // #ifdef HMI_DBUS_API + +std::string MessageHelper::CommonLanguageToString( + hmi_apis::Common_Language::eType language) { + switch (language) { + case hmi_apis::Common_Language::EN_US: + return "en-us"; + case hmi_apis::Common_Language::ES_MX: + return "es-mx"; + case hmi_apis::Common_Language::FR_CA: + return "fr-ca"; + case hmi_apis::Common_Language::DE_DE: + return "de-de"; + case hmi_apis::Common_Language::ES_ES: + return "es-es"; + case hmi_apis::Common_Language::EN_GB: + return "en-gb"; + case hmi_apis::Common_Language::RU_RU: + return "ru-ru"; + case hmi_apis::Common_Language::TR_TR: + return "tr-tr"; + case hmi_apis::Common_Language::PL_PL: + return "pl-pl"; + case hmi_apis::Common_Language::FR_FR: + return "fr-fr"; + case hmi_apis::Common_Language::IT_IT: + return "it-it"; + case hmi_apis::Common_Language::SV_SE: + return "sv-se"; + case hmi_apis::Common_Language::PT_PT: + return "pt-pt"; + case hmi_apis::Common_Language::NL_NL: + return "nl-nl"; + case hmi_apis::Common_Language::EN_AU: + return "en-au"; + case hmi_apis::Common_Language::ZH_CN: + return "zh-cn"; + case hmi_apis::Common_Language::ZH_TW: + return "zh-tw"; + case hmi_apis::Common_Language::JA_JP: + return "ja-jp"; + case hmi_apis::Common_Language::AR_SA: + return "as-sa"; + case hmi_apis::Common_Language::KO_KR: + return "ko-kr"; + case hmi_apis::Common_Language::PT_BR: + return "pt-br"; + case hmi_apis::Common_Language::CS_CZ: + return "cs-cz"; + case hmi_apis::Common_Language::DA_DK: + return "da-dk"; + case hmi_apis::Common_Language::NO_NO: + return "no-no"; + default: + return ""; + } +} + +uint32_t MessageHelper::GetAppCommandLimit(const std::string& policy_app_id) { + + std::string priority; + policy::PolicyHandler::instance()->GetPriority(policy_app_id, &priority); + return policy::PolicyHandler::instance()->GetNotificationsNumber(priority); +} + +void MessageHelper::SendHMIStatusNotification( + const Application& application_impl) { + smart_objects::SmartObject* notification = new smart_objects::SmartObject; + if (!notification) { + // TODO(VS): please add logger. + return; + } + smart_objects::SmartObject& message = *notification; + + message[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_api::FunctionID::OnHMIStatusID); + + message[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + + message[strings::params][strings::connection_key] = + static_cast<int32_t>(application_impl.app_id()); + + message[strings::msg_params][strings::hmi_level] = + static_cast<int32_t>(application_impl.hmi_level()); + + message[strings::msg_params][strings::audio_streaming_state] = + static_cast<int32_t>(application_impl.audio_streaming_state()); + + message[strings::msg_params][strings::system_context] = + static_cast<int32_t>(application_impl.system_context()); + + ApplicationManagerImpl::instance()->ManageMobileCommand(notification); +} + +void MessageHelper::SendOnAppRegisteredNotificationToHMI( + const Application& application_impl, bool resumption) { + smart_objects::SmartObject* notification = new smart_objects::SmartObject; + if (!notification) { + // TODO(VS): please add logger. + return; + } + smart_objects::SmartObject& message = *notification; + + message[strings::params][strings::function_id] = + static_cast<int32_t>(hmi_apis::FunctionID::BasicCommunication_OnAppRegistered); + + message[strings::params][strings::message_type] = + static_cast<int32_t>(application_manager::MessageType::kNotification); + message[strings::msg_params][strings::application][strings::app_name] = + application_impl.name(); + + const smart_objects::SmartObject* ngn_media_screen_name = application_impl + .ngn_media_screen_name(); + + if (resumption) { + message[strings::msg_params][strings::resume_vr_grammars] = true; + } + + if (ngn_media_screen_name) { + message[strings::msg_params][strings::application][strings::ngn_media_screen_app_name] = + *ngn_media_screen_name; + } + + message[strings::msg_params][strings::application][strings::icon] = + application_impl.app_icon_path(); + + std::string dev_name = ApplicationManagerImpl::instance()->GetDeviceName( + application_impl.device()); + message[strings::msg_params][strings::application][strings::device_name] = + dev_name; + + message[strings::msg_params][strings::application][strings::app_id] = + application_impl.app_id(); + + message[strings::msg_params][strings::application][strings::hmi_display_language_desired] = + static_cast<int32_t>(application_impl.ui_language()); + + message[strings::msg_params][strings::application][strings::is_media_application] = + application_impl.is_media_application(); + + const smart_objects::SmartObject* app_type = application_impl.app_types(); + + if (app_type) { + message[strings::msg_params][strings::application][strings::app_type] = + *app_type; + } + if (application_impl.vr_synonyms()) { + message[strings::msg_params][strings::vr_synonyms] = *(application_impl + .vr_synonyms()); + } + if (application_impl.tts_name()) { + message[strings::msg_params][strings::tts_name] = *(application_impl + .tts_name()); + } + std::string priority; + + policy::PolicyHandler::instance()->GetPriority( + application_impl.mobile_app_id()->asString(), &priority); + if (!priority.empty()) { + message[strings::msg_params][strings::priority] = GetPriorityCode(priority); + } + + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(notification)); +} + +smart_objects::SmartObject* MessageHelper::GetHashUpdateNotification( + const uint32_t app_id) { + + LOG4CXX_INFO(logger_, "GetHashUpdateNotification" << app_id); + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + app_id); + + smart_objects::SmartObject* message = NULL; + if (NULL == app.get()) { + return message; + } + + message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + (*message)[strings::params][strings::function_id] = + mobile_apis::FunctionID::OnHashChangeID; + (*message)[strings::params][strings::connection_key] = app_id; + (*message)[strings::params][strings::message_type] = + static_cast<int32_t>(kNotification);; + + return message; +} + +void MessageHelper::SendHashUpdateNotification(const uint32_t app_id) { + LOG4CXX_INFO(logger_, "SendHashUpdateNotification"); + + smart_objects::SmartObject* so = GetHashUpdateNotification(app_id); + if (so) { + PrintSmartObject(*so); + if (!ApplicationManagerImpl::instance()->ManageMobileCommand(so)) { + LOG4CXX_ERROR_EXT(logger_, "Failed to send HashUpdate notification."); + } + } +} + +void MessageHelper::SendOnAppInterfaceUnregisteredNotificationToMobile( + int32_t connection_key, + mobile_api::AppInterfaceUnregisteredReason::eType reason) { + smart_objects::SmartObject* notification = new smart_objects::SmartObject; + if (!notification) { + // TODO(VS): please add logger. + return; + } + smart_objects::SmartObject& message = *notification; + + message[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_api::FunctionID::OnAppInterfaceUnregisteredID); + + message[strings::params][strings::message_type] = + static_cast<int32_t>(kNotification); + + message[strings::params][strings::connection_key] = connection_key; + + message[strings::msg_params][strings::reason] = static_cast<int32_t>(reason); + + DCHECK(ApplicationManagerImpl::instance()->ManageMobileCommand(notification)); +} + +const VehicleData& MessageHelper::vehicle_data() { + return vehicle_data_; +} + +mobile_apis::HMILevel::eType MessageHelper::StringToHMILevel( + const std::string& hmi_level) { + using namespace NsSmartDeviceLink::NsSmartObjects; + mobile_apis::HMILevel::eType value; + if (EnumConversionHelper<mobile_apis::HMILevel::eType>::StringToEnum( + hmi_level, &value)) { + return value; + } + return mobile_apis::HMILevel::INVALID_ENUM; +} + +std::string MessageHelper::StringifiedHMILevel( + mobile_apis::HMILevel::eType hmi_level) { + using namespace NsSmartDeviceLink::NsSmartObjects; + const char* str = 0; + if (EnumConversionHelper<mobile_apis::HMILevel::eType>::EnumToCString( + hmi_level, &str)) { + return str; + } + return std::string(); +} + +std::string MessageHelper::StringifiedFunctionID( + mobile_apis::FunctionID::eType function_id) { + using namespace NsSmartDeviceLink::NsSmartObjects; + const char* str = 0; + if (EnumConversionHelper<mobile_apis::FunctionID::eType>::EnumToCString( + function_id, &str)) { + const std::string enum_name = str; + // Strip 'ID' suffix from value name + DCHECK(enum_name.length() > 2 + && enum_name.substr(enum_name.length() - 2) == "ID"); + return enum_name.substr(0, enum_name.length() - 2); + } + return std::string(); +} + +#ifdef HMI_DBUS_API +namespace { +const std::map<std::string, uint16_t> create_get_vehicle_data_args() { + std::map<std::string, uint16_t> rc; + rc.insert(std::make_pair(strings::gps, hmi_apis::FunctionID::VehicleInfo_GetGpsData)); + rc.insert(std::make_pair(strings::speed, hmi_apis::FunctionID::VehicleInfo_GetSpeed)); + rc.insert(std::make_pair(strings::rpm, hmi_apis::FunctionID::VehicleInfo_GetRpm)); + rc.insert(std::make_pair(strings::fuel_level, hmi_apis::FunctionID::VehicleInfo_GetFuelLevel)); + rc.insert(std::make_pair(strings::fuel_level_state, hmi_apis::FunctionID::VehicleInfo_GetFuelLevelState)); + rc.insert(std::make_pair(strings::instant_fuel_consumption, hmi_apis::FunctionID::VehicleInfo_GetInstantFuelConsumption)); + rc.insert(std::make_pair(strings::external_temp, hmi_apis::FunctionID::VehicleInfo_GetExternalTemperature)); + rc.insert(std::make_pair(strings::vin, hmi_apis::FunctionID::VehicleInfo_GetVin)); + rc.insert(std::make_pair(strings::prndl, hmi_apis::FunctionID::VehicleInfo_GetPrndl)); + rc.insert(std::make_pair(strings::tire_pressure, hmi_apis::FunctionID::VehicleInfo_GetTirePressure)); + rc.insert(std::make_pair(strings::odometer, hmi_apis::FunctionID::VehicleInfo_GetOdometer)); + rc.insert(std::make_pair(strings::belt_status, hmi_apis::FunctionID::VehicleInfo_GetBeltStatus)); + rc.insert(std::make_pair(strings::body_information, hmi_apis::FunctionID::VehicleInfo_GetBodyInformation)); + rc.insert(std::make_pair(strings::device_status, hmi_apis::FunctionID::VehicleInfo_GetDeviceStatus)); + rc.insert(std::make_pair(strings::driver_braking, hmi_apis::FunctionID::VehicleInfo_GetDriverBraking)); + rc.insert(std::make_pair(strings::wiper_status, hmi_apis::FunctionID::VehicleInfo_GetWiperStatus)); + rc.insert(std::make_pair(strings::head_lamp_status, hmi_apis::FunctionID::VehicleInfo_GetHeadLampStatus)); + rc.insert(std::make_pair(strings::engine_torque, hmi_apis::FunctionID::VehicleInfo_GetEngineTorque)); + rc.insert(std::make_pair(strings::acc_pedal_pos, hmi_apis::FunctionID::VehicleInfo_GetAccPedalPosition)); + rc.insert(std::make_pair(strings::steering_wheel_angle, hmi_apis::FunctionID::VehicleInfo_GetSteeringWheelAngle)); + rc.insert(std::make_pair(strings::e_call_info, hmi_apis::FunctionID::VehicleInfo_GetECallInfo)); + rc.insert(std::make_pair(strings::airbag_status, hmi_apis::FunctionID::VehicleInfo_GetAirbagStatus)); + rc.insert(std::make_pair(strings::emergency_event, hmi_apis::FunctionID::VehicleInfo_GetEmergencyEvent)); + rc.insert(std::make_pair(strings::cluster_mode_status, hmi_apis::FunctionID::VehicleInfo_GetClusterModeStatus)); + rc.insert(std::make_pair(strings::my_key, hmi_apis::FunctionID::VehicleInfo_GetMyKey)); + return rc; +} +static std::map<std::string, uint16_t> vehicle_data_args = create_get_vehicle_data_args(); +} +#endif + +void MessageHelper::CreateGetVehicleDataRequest(uint32_t correlation_id, const std::vector<std::string>& params) { +#ifdef HMI_DBUS_API + for (std::vector<std::string>::const_iterator it = params.begin(); + it != params.end(); it++) { + smart_objects::SmartObject* request = new smart_objects::SmartObject; + + (*request)[strings::params][strings::message_type] = static_cast<int>(kRequest); + (*request)[strings::params][strings::correlation_id] = correlation_id; + (*request)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*request)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*request)[strings::params][strings::function_id] = + static_cast<int>(vehicle_data_args[*it]); + ApplicationManagerImpl::instance()->ManageHMICommand(request); + } +#else + smart_objects::SmartObject* request = new smart_objects::SmartObject; + + (*request)[strings::params][strings::message_type] = static_cast<int>(kRequest); + (*request)[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::VehicleInfo_GetVehicleData); + (*request)[strings::params][strings::correlation_id] = correlation_id; + (*request)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*request)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*request)[strings::msg_params] = smart_objects::SmartObject(smart_objects::SmartType_Map); + for (std::vector<std::string>::const_iterator it = params.begin(); + it != params.end(); it++) { + (*request)[strings::msg_params][*it] = true; + } + ApplicationManagerImpl::instance()->ManageHMICommand(request); +#endif +} + +smart_objects::SmartObject* MessageHelper::CreateBlockedByPoliciesResponse( + mobile_apis::FunctionID::eType function_id, + mobile_apis::Result::eType result, uint32_t correlation_id, + uint32_t connection_key) { + smart_objects::SmartObject* response = new smart_objects::SmartObject; + if (!response) { + return NULL; + } + + (*response)[strings::params][strings::function_id] = + static_cast<int>(function_id); + (*response)[strings::params][strings::message_type] = + static_cast<int>(kResponse); + (*response)[strings::msg_params][strings::success] = false; + (*response)[strings::msg_params][strings::result_code] = + static_cast<int>(result); + (*response)[strings::params][strings::correlation_id] = correlation_id; + (*response)[strings::params][strings::connection_key] = connection_key; + (*response)[strings::params][strings::protocol_type] = + commands::CommandImpl::mobile_protocol_type_; + (*response)[strings::params][strings::protocol_version] = + static_cast<int>(kV2); + return response; +} + +smart_objects::SmartObject* MessageHelper::CreateDeviceListSO( + const connection_handler::DeviceMap& devices) { + smart_objects::SmartObject* device_list_so = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (NULL == device_list_so) { + return NULL; + } + + (*device_list_so)[strings::device_list] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + smart_objects::SmartObject& list_so = (*device_list_so)[strings::device_list]; + + int32_t index = 0; + for (connection_handler::DeviceMap::const_iterator it = devices.begin(); + devices.end() != it; ++it) { + const connection_handler::Device& d = + static_cast<connection_handler::Device>(it->second); + list_so[index][strings::name] = d.user_friendly_name(); + list_so[index][strings::id] = it->second.device_handle(); + + const policy::DeviceConsent device_consent = + policy::PolicyHandler::instance()->GetUserConsentForDevice(it->second.mac_address()); + list_so[index][strings::isSDLAllowed] = + policy::DeviceConsent::kDeviceAllowed == device_consent; + } + ++index; + return device_list_so; +} + +smart_objects::SmartObject* MessageHelper::CreateModuleInfoSO( + uint32_t function_id) { + smart_objects::SmartObject* module_info = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject& object = *module_info; + object[strings::params][strings::message_type] = static_cast<int>(kRequest); + object[strings::params][strings::function_id] = static_cast<int>(function_id); + object[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + object[strings::msg_params] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + return module_info; +} + +smart_objects::SmartObject* MessageHelper::CreateSetAppIcon( + const std::string& path_to_icon, uint32_t app_id) { + smart_objects::SmartObject* set_icon = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!set_icon) { + return NULL; + } + + smart_objects::SmartObject& object = *set_icon; + object[strings::sync_file_name][strings::value] = path_to_icon; + // TODO(PV): need to store actual image type + object[strings::sync_file_name][strings::image_type] = + static_cast<int>(mobile_api::ImageType::DYNAMIC); + object[strings::app_id] = app_id; + + return set_icon; +} + +bool MessageHelper::SendIVISubscribtions(const uint32_t app_id) { + LOG4CXX_INFO(logger_, " MessageHelper::SendIVISubscribtions "); + + bool succes = true; + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + app_id); + DCHECK(app.get()); + + SmartObjectList requests = GetIVISubscribtionRequests(app_id); + for (SmartObjectList::const_iterator it = requests.begin(); + it != requests.end(); ++it) { + if (!ApplicationManagerImpl::instance()->ManageHMICommand(*it)) { + succes = false; + } + } + return succes; +} + +MessageHelper::SmartObjectList MessageHelper::GetIVISubscribtionRequests( + const uint32_t app_id) { + LOG4CXX_INFO(logger_, " MessageHelper::GetIVISubscribtionRequests "); + + ApplicationSharedPtr app = ApplicationManagerImpl::instance()->application( + app_id); + DCHECK(app); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::app_id] = app_id; + const VehicleData& vehicle_data = MessageHelper::vehicle_data_; + VehicleData::const_iterator ivi_it = vehicle_data.begin(); + const std::set<uint32_t>& subscribes = app->SubscribesIVI(); + + for (; vehicle_data.end() != ivi_it; ++ivi_it) { + uint32_t type_id = static_cast<int>(ivi_it->second); + if (subscribes.end() != subscribes.find(type_id)) { + std::string key_name = ivi_it->first; + msg_params[key_name] = true; + } + } + + SmartObjectList hmi_requests; +#ifdef HMI_JSON_API + smart_objects::SmartObject* request = MessageHelper::CreateModuleInfoSO( + hmi_apis::FunctionID::VehicleInfo_SubscribeVehicleData); + (*request)[strings::msg_params] = msg_params; + hmi_requests.push_back(request); +#endif // #ifdef HMI_JSON_API +#ifdef HMI_DBUS_API + //Generate list of ivi_subrequests + for (size_t i = 0; i < sizeof(ivi_subrequests) / sizeof(ivi_subrequests[0]); ++i) { + const VehicleInfo_Requests& sr = ivi_subrequests[i]; + if (true == msg_params.keyExists(sr.str) + && true == msg_params[sr.str].asBool()) { + smart_objects::SmartObject* request = MessageHelper::CreateModuleInfoSO( + sr.func_id); + (*request)[strings::msg_params] = msg_params; + hmi_requests.push_back(request); + } + } +#endif // #ifdef HMI_DBUS_API + return hmi_requests; +} + +void MessageHelper::SendAppDataToHMI(ApplicationConstSharedPtr app) { + uint32_t id = app->app_id(); + + utils::SharedPtr<smart_objects::SmartObject> set_app_icon( + new smart_objects::SmartObject); + if (set_app_icon) { + smart_objects::SmartObject& so_to_send = *set_app_icon; + so_to_send[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::UI_SetAppIcon); + so_to_send[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + so_to_send[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + so_to_send[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + so_to_send[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + so_to_send[strings::msg_params] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject* msg_params = MessageHelper::CreateSetAppIcon( + app->app_icon_path(), id); + + if (msg_params) { + so_to_send[strings::msg_params] = *msg_params; + } + // TODO(PV): appropriate handling of result + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(set_app_icon)); + } + + SendGlobalPropertiesToHMI(app); + SendShowRequestToHMI(app); +} + +void MessageHelper::SendGlobalPropertiesToHMI(ApplicationConstSharedPtr app) { + DCHECK(app.get()); + + SmartObjectList requests = CreateGlobalPropertiesRequestsToHMI(app); + for (SmartObjectList::const_iterator it = requests.begin(); + it != requests.end(); ++it) { + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(*it)) + } +} + +MessageHelper::SmartObjectList MessageHelper::CreateGlobalPropertiesRequestsToHMI( + ApplicationConstSharedPtr app) { + + SmartObjectList requests; + DCHECK(app.get()); + + // UI global properties + + if (app->vr_help_title() || app->vr_help()) { + smart_objects::SmartObject* ui_global_properties = + new smart_objects::SmartObject(smart_objects::SmartType_Map); + + if (!ui_global_properties) { + return requests; + } + + (*ui_global_properties)[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::UI_SetGlobalProperties); + (*ui_global_properties)[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + (*ui_global_properties)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*ui_global_properties)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*ui_global_properties)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject ui_msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (app->vr_help_title()) { + ui_msg_params[strings::vr_help_title] = (*app->vr_help_title()); + } + if (app->vr_help()) { + ui_msg_params[strings::vr_help] = (*app->vr_help()); + } + if (app->keyboard_props()) { + ui_msg_params[strings::keyboard_properties] = (*app->keyboard_props()); + } + if (app->menu_title()) { + ui_msg_params[strings::menu_title] = (*app->menu_title()); + } + if (app->menu_icon()) { + ui_msg_params[strings::menu_icon] = (*app->menu_icon()); + } + ui_msg_params[strings::app_id] = app->app_id(); + + (*ui_global_properties)[strings::msg_params] = ui_msg_params; + + requests.push_back(ui_global_properties); + } + + // TTS global properties + if (app->help_prompt() || app->timeout_prompt()) { + smart_objects::SmartObject* tts_global_properties = + new smart_objects::SmartObject(smart_objects::SmartType_Map); + + if (!tts_global_properties) { + return requests; + } + + (*tts_global_properties)[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::TTS_SetGlobalProperties); + (*tts_global_properties)[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + (*tts_global_properties)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*tts_global_properties)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*tts_global_properties)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject tts_msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (app->help_prompt()) { + tts_msg_params[strings::help_prompt] = (*app->help_prompt()); + } + if (app->timeout_prompt()) { + tts_msg_params[strings::timeout_prompt] = (*app->timeout_prompt()); + } + tts_msg_params[strings::app_id] = app->app_id(); + + (*tts_global_properties)[strings::msg_params] = tts_msg_params; + + requests.push_back(tts_global_properties); + } + return requests; +} + +void MessageHelper::SendTTSGlobalProperties( + ApplicationSharedPtr app, bool default_help_prompt) { + if (!app.valid()) { + return; + } + utils::SharedPtr<smart_objects::SmartObject> tts_global_properties( + new smart_objects::SmartObject); + if (tts_global_properties) { + smart_objects::SmartObject& so_to_send = *tts_global_properties; + so_to_send[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::TTS_SetGlobalProperties); + so_to_send[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + so_to_send[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + so_to_send[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + so_to_send[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::help_prompt] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + if (default_help_prompt) { + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator it = commands.begin(); + uint32_t index = 0; + for (; commands.end() != it; ++it) { + smart_objects::SmartObject item(smart_objects::SmartType_Map); + if ((*it->second).keyExists(strings::menu_params)){ + item[strings::text] = (*it->second)[strings::menu_params][strings::menu_name].asString(); + item[strings::type] = mobile_apis::SpeechCapabilities::SC_TEXT; + } else { + continue; + } + msg_params[strings::help_prompt][index++] = item; + } + } + app->set_help_prompt(msg_params[strings::help_prompt]); + msg_params[strings::app_id] = app->app_id(); + so_to_send[strings::msg_params] = msg_params; + ApplicationManagerImpl::instance()->ManageHMICommand(tts_global_properties); + } +} + +smart_objects::SmartObject* MessageHelper::CreateAppVrHelp( + ApplicationConstSharedPtr app) { + smart_objects::SmartObject* result = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!result) { + return NULL; + } + smart_objects::SmartObject& vr_help = *result; + vr_help[strings::vr_help_title] = app->name(); + + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> apps = accessor.applications(); + + int32_t index = 0; + std::set<ApplicationSharedPtr>::const_iterator it_app = apps.begin(); + for (; apps.end() != it_app; ++it_app) { + if ((*it_app)->vr_synonyms()) { + smart_objects::SmartObject item(smart_objects::SmartType_Map); + item[strings::text] = (*((*it_app)->vr_synonyms())).getElement(0); + item[strings::position] = index + 1; + vr_help[strings::vr_help][index++] = item; + } + } + + // copy all app VR commands + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator it = commands.begin(); + + for (; commands.end() != it; ++it) { + smart_objects::SmartObject item(smart_objects::SmartType_Map); + item[strings::text] = (*it->second)[strings::vr_commands][0].asString(); + item[strings::position] = index + 1; + vr_help[strings::vr_help][index++] = item; + } + return result; +} + +MessageHelper::SmartObjectList MessageHelper::CreateShowRequestToHMI( + ApplicationConstSharedPtr app) { + DCHECK(app.get()); + + SmartObjectList requests; + smart_objects::SmartObject* ui_show = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (app->show_command()) { + (*ui_show)[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::UI_Show); + (*ui_show)[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + (*ui_show)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*ui_show)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*ui_show)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + (*ui_show)[strings::msg_params] = (*app->show_command()); + requests.push_back(ui_show); + } + return requests; +} + +void MessageHelper::SendShowRequestToHMI(ApplicationConstSharedPtr app) { + if (!app) { + return; + } + SmartObjectList shows = CreateShowRequestToHMI(app); + + for (SmartObjectList::const_iterator it = shows.begin(); it != shows.end(); + ++it) { + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(*it)); + } + +} + +void MessageHelper::SendShowConstantTBTRequestToHMI( + ApplicationConstSharedPtr app) { + if (!app) { + return; + } + + smart_objects::SmartObject* navi_show_tbt = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!navi_show_tbt) { + return; + } + + if (app->tbt_show_command()) { + (*navi_show_tbt)[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::Navigation_ShowConstantTBT); + (*navi_show_tbt)[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + (*navi_show_tbt)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*navi_show_tbt)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*navi_show_tbt)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + (*navi_show_tbt)[strings::msg_params] = (*app->tbt_show_command()); + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(navi_show_tbt)); + } +} + +void MessageHelper::SendAddCommandRequestToHMI(ApplicationConstSharedPtr app) { + if (!app) { + return; + } + SmartObjectList requests = CreateAddCommandRequestToHMI(app); + for (SmartObjectList::iterator it = requests.begin(); it != requests.end(); + ++it) { + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(*it)); + } +} + +MessageHelper::SmartObjectList MessageHelper::CreateAddCommandRequestToHMI( + ApplicationConstSharedPtr app) { + DCHECK(app.get()); + + SmartObjectList requests; + const CommandsMap& commands = app->commands_map(); + CommandsMap::const_iterator i = commands.begin(); + for (; commands.end() != i; ++i) { + // UI Interface + if ((*i->second).keyExists(strings::menu_params)) { + smart_objects::SmartObject* ui_command = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!ui_command) { + return requests; + } + + (*ui_command)[strings::params][strings::function_id] = + static_cast<int>(hmi_apis::FunctionID::UI_AddCommand); + (*ui_command)[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + (*ui_command)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*ui_command)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*ui_command)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::cmd_id] = i->first; + msg_params[strings::menu_params] = (*i->second)[strings::menu_params]; + msg_params[strings::app_id] = app->app_id(); + + if (((*i->second)[strings::cmd_icon].keyExists(strings::value)) + && (0 < (*i->second)[strings::cmd_icon][strings::value].length())) { + msg_params[strings::cmd_icon] = (*i->second)[strings::cmd_icon]; + msg_params[strings::cmd_icon][strings::value] = + (*i->second)[strings::cmd_icon][strings::value].asString(); + } + (*ui_command)[strings::msg_params] = msg_params; + requests.push_back(ui_command); + } + + // VR Interface + if ((*i->second).keyExists(strings::vr_commands)) { + SendAddVRCommandToHMI(i->first, (*i->second)[strings::vr_commands], + app->app_id()); + } + } + return requests; +} + +smart_objects::SmartObject* MessageHelper::CreateChangeRegistration( + int32_t function_id, int32_t language, uint32_t app_id) { + smart_objects::SmartObject* command = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!command) { + return NULL; + } + smart_objects::SmartObject& params = *command; + + params[strings::params][strings::message_type] = + static_cast<int>(hmi_apis::messageType::request); + params[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + params[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + + params[strings::params][strings::function_id] = function_id; + + params[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + msg_params[strings::language] = language; + msg_params[strings::app_id] = app_id; + + params[strings::msg_params] = msg_params; + return command; +} + +void MessageHelper::SendChangeRegistrationRequestToHMI(ApplicationConstSharedPtr app) { + if (!app.valid()) { + return; + } + if (mobile_apis::Language::INVALID_ENUM != app->language()) { + smart_objects::SmartObject* vr_command = CreateChangeRegistration( + hmi_apis::FunctionID::VR_ChangeRegistration, app->language(), + app->app_id()); + + if (vr_command) { + ApplicationManagerImpl::instance()->ManageHMICommand(vr_command); + } + } + + if (mobile_apis::Language::INVALID_ENUM != app->language()) { + smart_objects::SmartObject* tts_command = CreateChangeRegistration( + hmi_apis::FunctionID::TTS_ChangeRegistration, app->language(), + app->app_id()); + + if (tts_command) { + ApplicationManagerImpl::instance()->ManageHMICommand(tts_command); + } + } + + if (mobile_apis::Language::INVALID_ENUM != app->ui_language()) { + smart_objects::SmartObject* ui_command = CreateChangeRegistration( + hmi_apis::FunctionID::UI_ChangeRegistration, app->ui_language(), + app->app_id()); + + if (ui_command) { + ApplicationManagerImpl::instance()->ManageHMICommand(ui_command); + } + + } +} + +void MessageHelper::SendAddVRCommandToHMI( + uint32_t cmd_id, const smart_objects::SmartObject& vr_commands, + uint32_t app_id) { + smart_objects::SmartObject* request = CreateAddVRCommandToHMI(cmd_id, + vr_commands, + app_id); + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(request)); +} + +smart_objects::SmartObject* MessageHelper::CreateAddVRCommandToHMI( + uint32_t cmd_id, + const NsSmartDeviceLink::NsSmartObjects::SmartObject& vr_commands, + uint32_t app_id) { + smart_objects::SmartObject* vr_command = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!vr_command) { + return NULL; + } + + (*vr_command)[strings::params][strings::function_id] = + hmi_apis::FunctionID::VR_AddCommand; + (*vr_command)[strings::params][strings::message_type] = + hmi_apis::messageType::request; + (*vr_command)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*vr_command)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*vr_command)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (0 != cmd_id) { + msg_params[strings::cmd_id] = cmd_id; + } + msg_params[strings::vr_commands] = vr_commands; + if (0 < app_id) { + msg_params[strings::app_id] = app_id; + } + msg_params[strings::grammar_id] = + ApplicationManagerImpl::instance()->application(app_id)->get_grammar_id(); + msg_params[strings::type] = hmi_apis::Common_VRCommandType::Command; + + (*vr_command)[strings::msg_params] = msg_params; + + return vr_command; +} + +bool MessageHelper::CreateHMIApplicationStruct(ApplicationConstSharedPtr app, + smart_objects::SmartObject& output) { + + if (false == app.valid()) { + return false; + } + + const smart_objects::SmartObject* app_types = app->app_types(); + const smart_objects::SmartObject* ngn_media_screen_name = app->ngn_media_screen_name(); + const connection_handler::DeviceHandle handle = app->device(); + std::string device_name = ApplicationManagerImpl::instance()->GetDeviceName(handle); + + output = smart_objects::SmartObject(smart_objects::SmartType_Map); + output[strings::app_name] = app->name(); + output[strings::icon] = app->app_icon_path(); + output[strings::device_name] = device_name; + output[strings::app_id] = app->app_id(); + output[strings::hmi_display_language_desired] = app->ui_language(); + output[strings::is_media_application] = app->is_media_application(); + + if (NULL != ngn_media_screen_name) { + output[strings::ngn_media_screen_app_name] = ngn_media_screen_name->asString(); + } + if (NULL != app_types) { + output[strings::app_type] = *app_types; + } + return true; +} + +void MessageHelper::SendAddSubMenuRequestToHMI(ApplicationConstSharedPtr app) { + DCHECK(app.get()); + SmartObjectList requests = CreateAddSubMenuRequestToHMI(app); + for (SmartObjectList::iterator it = requests.begin(); it != requests.end(); + ++it) { + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(*it)); + } +} + +MessageHelper::SmartObjectList MessageHelper::CreateAddSubMenuRequestToHMI( + ApplicationConstSharedPtr app) { + SmartObjectList requsets; + const SubMenuMap& sub_menu = app->sub_menu_map(); + SubMenuMap::const_iterator i = sub_menu.begin(); + for (; sub_menu.end() != i; ++i) { + smart_objects::SmartObject* ui_sub_menu = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!ui_sub_menu) { + return requsets; + } + + (*ui_sub_menu)[strings::params][strings::function_id] = + hmi_apis::FunctionID::UI_AddSubMenu; + (*ui_sub_menu)[strings::params][strings::message_type] = + hmi_apis::messageType::request; + (*ui_sub_menu)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*ui_sub_menu)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*ui_sub_menu)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + msg_params[strings::menu_id] = i->first; + msg_params[strings::menu_params][strings::position] = + (*i->second)[strings::position]; + msg_params[strings::menu_params][strings::menu_name] = + (*i->second)[strings::menu_name]; + msg_params[strings::app_id] = app->app_id(); + (*ui_sub_menu)[strings::msg_params] = msg_params; + requsets.push_back(ui_sub_menu); + } + return requsets; +} + +void MessageHelper::SendOnAppUnregNotificationToHMI( + ApplicationConstSharedPtr app, bool is_unexpected_disconnect) { + smart_objects::SmartObject* notification = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!notification) { + return; + } + + smart_objects::SmartObject& message = *notification; + + message[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_OnAppUnregistered; + + message[strings::params][strings::message_type] = MessageType::kNotification; + // we put hmi_app_id because applicaton list does not contain application on this momment + // and ReplaceHMIByMobileAppId function will be unable to replace app_id to hmi_app_id + message[strings::msg_params][strings::app_id] = app->hmi_app_id(); + message[strings::msg_params][strings::unexpected_disconnect] = + is_unexpected_disconnect; + ApplicationManagerImpl::instance()->ManageHMICommand(&message); +} + +void MessageHelper::SendActivateAppToHMI(uint32_t const app_id, + hmi_apis::Common_HMILevel::eType level) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + application_manager::ApplicationConstSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application(app_id); + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Invalid app_id: " << app_id); + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_ActivateApp; + (*message)[strings::params][strings::message_type] = MessageType::kRequest; + (*message)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + (*message)[strings::msg_params][strings::app_id] = app_id; + + std::string priority; + // TODO(KKolodiy): need remove method policy_manager + + policy::PolicyHandler::instance()->GetPriority( + app->mobile_app_id()->asString(), &priority); + // According SDLAQ-CRS-2794 + // SDL have to send ActivateApp without "proirity" parameter to HMI. + // in case of unconsented device + std::string mac_adress; + connection_handler::DeviceHandle device_handle = app->device(); + connection_handler::ConnectionHandlerImpl::instance()-> + GetDataOnDeviceID(device_handle, NULL, NULL, &mac_adress, NULL); + + policy::DeviceConsent consent = + policy::PolicyHandler::instance()->GetUserConsentForDevice(mac_adress); + if (!priority.empty() && (policy::DeviceConsent::kDeviceAllowed == consent)) { + (*message)[strings::msg_params]["priority"] = GetPriorityCode(priority); + } + + if (hmi_apis::Common_HMILevel::INVALID_ENUM != level) { + (*message)[strings::msg_params][strings::activate_app_hmi_level] = level; + } + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +void MessageHelper::SendOnResumeAudioSourceToHMI(const uint32_t app_id) { + LOG4CXX_WARN(logger_, "SendOnResumeAudioSourceToHMI app_id: " << app_id); + + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + application_manager::ApplicationConstSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application(app_id); + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Invalid app_id: " << app_id); + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_OnResumeAudioSource; + (*message)[strings::params][strings::message_type] = MessageType::kNotification; + (*message)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + (*message)[strings::msg_params][strings::app_id] = app_id; + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +std::string MessageHelper::GetDeviceMacAddressForHandle( + const uint32_t device_handle) { + + std::string device_mac_address = ""; + connection_handler::ConnectionHandlerImpl::instance()->GetDataOnDeviceID( + device_handle, NULL, NULL, &device_mac_address); + + return device_mac_address; +} + +void MessageHelper::GetDeviceInfoForHandle(const uint32_t device_handle, + policy::DeviceParams* device_info) { + if (!device_info) { + return; + } + connection_handler::ConnectionHandlerImpl::instance()->GetDataOnDeviceID( + device_handle, &device_info->device_name, NULL, + &device_info->device_mac_address, &device_info->device_connection_type); +} + +void MessageHelper::GetDeviceInfoForApp(uint32_t connection_key, + policy::DeviceParams* device_info) { + if (!device_info) { + return; + } + + device_info->device_handle = ApplicationManagerImpl::instance()->application( + connection_key)->device(); + + GetDeviceInfoForHandle(device_info->device_handle, device_info); +} + +void MessageHelper::SendSDLActivateAppResponse(policy::AppPermissions& permissions, + uint32_t correlation_id) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_ActivateApp; + (*message)[strings::params][strings::message_type] = MessageType::kResponse; + (*message)[strings::params][strings::correlation_id] = correlation_id; + (*message)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*message)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*message)[strings::params][hmi_response::code] = 0; + + (*message)[strings::msg_params]["isSDLAllowed"] = permissions.isSDLAllowed; + if (!permissions.isSDLAllowed) { + (*message)[strings::msg_params]["device"]["name"] = permissions.deviceInfo + .device_name; + (*message)[strings::msg_params]["device"]["id"] = permissions.deviceInfo + .device_handle; + } + + (*message)[strings::msg_params]["isAppRevoked"] = permissions.appRevoked; + (*message)[strings::msg_params]["isAppPermissionsRevoked"] = permissions + .isAppPermissionsRevoked; + + if (permissions.isAppPermissionsRevoked) { + FillAppRevokedPermissions(permissions, *message); + } + + (*message)[strings::msg_params]["isPermissionsConsentNeeded"] = permissions + .appPermissionsConsentNeeded; + + if (!permissions.priority.empty()) { + (*message)[strings::msg_params]["priority"] = GetPriorityCode( + permissions.priority); + } + + ApplicationManagerImpl::instance()->ManageHMICommand(message); + + // If application is revoked it should not be activated + if (permissions.appRevoked || !permissions.isSDLAllowed) { + return; + } + + // Send HMI status notification to mobile + ApplicationSharedPtr app = ApplicationManagerImpl::instance() + ->application_by_policy_id(permissions.application_id); + if (app) { + ApplicationManagerImpl::instance()->ActivateApplication(app); + } else { + LOG4CXX_WARN(logger_, "Unable to find app_id: " << permissions.application_id); + } +} + +void MessageHelper::SendOnSDLConsentNeeded( + const policy::DeviceParams& device_info) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_OnSDLConsentNeeded; + (*message)[strings::params][strings::message_type] = + MessageType::kNotification; + + (*message)[strings::msg_params]["device"]["id"] = device_info.device_handle; + (*message)[strings::msg_params]["device"]["name"] = device_info.device_name; + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +void MessageHelper::SendPolicyUpdate( + const std::string& file_path, + int timeout, + const std::vector<int>& retries) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject& object = *message; + object[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_PolicyUpdate; + object[strings::params][strings::message_type] = MessageType::kRequest; + object[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + object[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + object[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + + object[strings::msg_params][hmi_request::file] = file_path; + object[strings::msg_params][strings::timeout] = timeout; + object[strings::msg_params][hmi_request::retry] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + for (size_t i = 0; i < retries.size(); ++i) { + object[strings::msg_params][hmi_request::retry][i] = retries[i]; + } + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +void MessageHelper::SendGetUserFriendlyMessageResponse( + const std::vector<policy::UserFriendlyMessage>& msg, + uint32_t correlation_id) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_GetUserFriendlyMessage; + (*message)[strings::params][strings::message_type] = + MessageType::kResponse; + (*message)[strings::params][strings::correlation_id] = correlation_id; + (*message)[strings::params][hmi_response::code] = 0; + + // If no any messages found - skip sending of "messages" param + if (msg.empty()) { + ApplicationManagerImpl::instance()->ManageHMICommand(message); + } + + const std::string messages = "messages"; + (*message)[strings::msg_params][messages] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + + smart_objects::SmartObject& user_friendly_messages = + (*message)[strings::msg_params][messages]; + + + const std::string tts = "ttsString"; + const std::string label = "label"; + const std::string line1 = "line1"; + const std::string line2 = "line2"; + const std::string textBody = "textBody"; + const std::string message_code = "messageCode"; + + std::vector<policy::UserFriendlyMessage>::const_iterator it = msg.begin(); + std::vector<policy::UserFriendlyMessage>::const_iterator it_end = msg.end(); + for (uint32_t index = 0; it != it_end; ++it, ++index) { + user_friendly_messages[index] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& obj = user_friendly_messages[index]; + obj[message_code] = it->message_code; + + if (!it->tts.empty()) { + obj[tts] = it->tts; + } + if (!it->label.empty()) { + obj[label] = it->label; + } + if (!it->line1.empty()) { + obj[line1] = it->line1; + } + if (!it->line2.empty()) { + obj[line2] = it->line2; + } + if (!it->text_body.empty()) { + obj[textBody] = it->text_body; + } + } + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +void MessageHelper::SendGetListOfPermissionsResponse( + const std::vector<policy::FunctionalGroupPermission>& permissions, + uint32_t correlation_id) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_GetListOfPermissions; + (*message)[strings::params][strings::message_type] = + MessageType::kResponse; + (*message)[strings::params][strings::correlation_id] = correlation_id; + (*message)[strings::params][hmi_response::code] = 0; + + const std::string allowed_functions = "allowedFunctions"; + (*message)[strings::msg_params][allowed_functions] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + + smart_objects::SmartObject& allowed_functions_array = + (*message)[strings::msg_params][allowed_functions]; + + std::vector<policy::FunctionalGroupPermission>::const_iterator it = + permissions.begin(); + std::vector<policy::FunctionalGroupPermission>::const_iterator it_end = + permissions.end(); + for (uint32_t index = 0; it != it_end; ++it, ++index) { + allowed_functions_array[index] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& item = allowed_functions_array[index]; + item[strings::name] = (*it).group_alias; + item[strings::id] = (*it).group_id; + policy::GroupConsent permission_state = (*it).state; + // If state undefined, 'allowed' parameter should be absent + if (policy::kGroupUndefined != permission_state) { + item["allowed"] = policy::kGroupAllowed == permission_state; + } + } + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +smart_objects::SmartObject* MessageHelper::CreateNegativeResponse( + uint32_t connection_key, int32_t function_id, uint32_t correlation_id, + int32_t result_code) { + smart_objects::SmartObject* response = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject& response_data = *response; + response_data[strings::params][strings::function_id] = function_id; + response_data[strings::params][strings::message_type] = + mobile_apis::messageType::response; + response_data[strings::params][strings::correlation_id] = correlation_id; + response_data[strings::params][strings::protocol_type] = + commands::CommandImpl::mobile_protocol_type_; + response_data[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + response_data[strings::msg_params][strings::result_code] = result_code; + response_data[strings::msg_params][strings::success] = false; + response_data[strings::params][strings::connection_key] = connection_key; + + return response; +} + +void MessageHelper::SendNaviStartStream(int32_t connection_key) { + LOG4CXX_INFO(logger_, "MessageHelper::SendNaviStartStream"); + smart_objects::SmartObject* start_stream = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!start_stream) { + return; + } + + (*start_stream)[strings::params][strings::function_id] = + hmi_apis::FunctionID::Navigation_StartStream; + (*start_stream)[strings::params][strings::message_type] = + hmi_apis::messageType::request; + (*start_stream)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*start_stream)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*start_stream)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + uint32_t app_id = 0; + connection_handler::ConnectionHandlerImpl::instance()->GetDataOnSessionKey( + connection_key, &app_id); + + char url[100] = {'\0'}; + if ("socket" == profile::Profile::instance()->video_server_type()) { + snprintf(url, sizeof(url) / sizeof(url[0]), "http://%s:%d", + profile::Profile::instance()->server_address().c_str(), + profile::Profile::instance()->video_streaming_port()); + } else if ("pipe" == profile::Profile::instance()->video_server_type()) { + snprintf(url, sizeof(url) / sizeof(url[0]), "%s", + profile::Profile::instance()->named_video_pipe_path().c_str()); + } else { + int snprintf_result; + snprintf_result = snprintf(url, sizeof(url) / sizeof(url[0]), "%s", + profile::Profile::instance()->video_stream_file().c_str()); + DCHECK(snprintf_result); + } + msg_params[strings::app_id] = app_id; + msg_params[strings::url] = url; + + (*start_stream)[strings::msg_params] = msg_params; + + ApplicationManagerImpl::instance()->ManageHMICommand(start_stream); +} + +void MessageHelper::SendNaviStopStream(int32_t connection_key) { + smart_objects::SmartObject* stop_stream = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!stop_stream) { + return; + } + + (*stop_stream)[strings::params][strings::function_id] = + hmi_apis::FunctionID::Navigation_StopStream; + (*stop_stream)[strings::params][strings::message_type] = + hmi_apis::messageType::request; + (*stop_stream)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*stop_stream)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*stop_stream)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + uint32_t app_id = 0; + connection_handler::ConnectionHandlerImpl::instance()->GetDataOnSessionKey( + connection_key, &app_id); + + msg_params[strings::app_id] = app_id; + + (*stop_stream)[strings::msg_params] = msg_params; + + ApplicationManagerImpl::instance()->ManageHMICommand(stop_stream); +} + +void MessageHelper::SendAudioStartStream(int32_t connection_key) { + + smart_objects::SmartObject* start_stream = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!start_stream) { + return; + } + + (*start_stream)[strings::params][strings::function_id] = + hmi_apis::FunctionID::Navigation_StartAudioStream; + (*start_stream)[strings::params][strings::message_type] = + hmi_apis::messageType::request; + (*start_stream)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*start_stream)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*start_stream)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + uint32_t app_id = 0; + connection_handler::ConnectionHandlerImpl::instance()->GetDataOnSessionKey( + connection_key, &app_id); + + char url[100] = {'\0'}; + if ("socket" == profile::Profile::instance()->audio_server_type()) { + snprintf(url, sizeof(url) / sizeof(url[0]), "http://%s:%d", + profile::Profile::instance()->server_address().c_str(), + profile::Profile::instance()->audio_streaming_port()); + } else if ("pipe" == profile::Profile::instance()->audio_server_type()) { + snprintf(url, sizeof(url) / sizeof(url[0]), "%s", + profile::Profile::instance()->named_audio_pipe_path().c_str()); + } else { + int snprintf_result; + snprintf_result = snprintf(url, sizeof(url) / sizeof(url[0]), "%s", + profile::Profile::instance()->audio_stream_file().c_str()); + DCHECK(snprintf_result); + } + + msg_params[strings::app_id] = app_id; + msg_params[strings::url] = url; + + (*start_stream)[strings::msg_params] = msg_params; + + DCHECK(ApplicationManagerImpl::instance()->ManageHMICommand(start_stream)); +} + +void MessageHelper::SendAudioStopStream(int32_t connection_key) { + smart_objects::SmartObject* stop_stream = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + if (!stop_stream) { + return; + } + + (*stop_stream)[strings::params][strings::function_id] = + hmi_apis::FunctionID::Navigation_StopAudioStream; + (*stop_stream)[strings::params][strings::message_type] = + hmi_apis::messageType::request; + (*stop_stream)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*stop_stream)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + (*stop_stream)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + smart_objects::SmartObject msg_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + uint32_t app_id = 0; + connection_handler::ConnectionHandlerImpl::instance()->GetDataOnSessionKey( + connection_key, &app_id); + + msg_params[strings::app_id] = app_id; + + (*stop_stream)[strings::msg_params] = msg_params; + + ApplicationManagerImpl::instance()->ManageHMICommand(stop_stream); +} + +bool MessageHelper::SendStopAudioPathThru() { + LOG4CXX_INFO(logger_, "MessageHelper::SendAudioStopAudioPathThru"); + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + new NsSmartDeviceLink::NsSmartObjects::SmartObject; + const uint32_t hmi_correlation_id = ApplicationManagerImpl::instance() + ->GetNextHMICorrelationID(); + NsSmartDeviceLink::NsSmartObjects::SmartObject& request = *result; + request[strings::params][strings::message_type] = MessageType::kRequest; + request[strings::params][strings::function_id] = + hmi_apis::FunctionID::UI_EndAudioPassThru; + request[strings::params][strings::correlation_id] = hmi_correlation_id; + request[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + request[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + return ApplicationManagerImpl::instance()->ManageHMICommand(result); +} + +void MessageHelper::SendPolicySnapshotNotification( + unsigned int connection_key, const std::vector<uint8_t>& policy_data, + const std::string& url, int timeout) { + smart_objects::SmartObject* pt_notification = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject& content = *pt_notification; + ; + content[strings::params][strings::function_id] = + mobile_apis::FunctionID::OnSystemRequestID; + content[strings::params][strings::message_type] = + mobile_apis::messageType::notification; + content[strings::params][strings::protocol_type] = + commands::CommandImpl::mobile_protocol_type_; + content[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + content[strings::params][strings::connection_key] = connection_key; + if (!url.empty()) { + content[strings::msg_params][mobile_notification::syncp_url] = url; + } + content[strings::msg_params][strings::file_type] = + mobile_apis::FileType::BINARY; + content[strings::msg_params][strings::request_type] = + mobile_apis::RequestType::HTTP; + /*if (-1 != timeout) { + content[strings::msg_params][mobile_notification::syncp_timeout] = timeout; + }*/ + content[strings::params][strings::binary_data] = smart_objects::SmartObject( + policy_data); + ApplicationManagerImpl::instance()->ManageMobileCommand(pt_notification); +} + +void MessageHelper::SendOnPermissionsChangeNotification( + uint32_t connection_key, const policy::Permissions& permissions) { + smart_objects::SmartObject* notification = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject& content = *notification; + ; + content[strings::params][strings::function_id] = + mobile_apis::FunctionID::OnPermissionsChangeID; + content[strings::params][strings::message_type] = + mobile_apis::messageType::notification; + content[strings::params][strings::protocol_type] = + commands::CommandImpl::mobile_protocol_type_; + content[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + content[strings::params][strings::connection_key] = connection_key; + + smart_objects::SmartObject* p_msg_params = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& msg_params = *p_msg_params; + + content[strings::msg_params] = msg_params; + + //content[strings::msg_params][strings::app_id] = connection_key; + + content[strings::msg_params]["permissionItem"] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + + smart_objects::SmartObject& permissions_item_array = + content[strings::msg_params]["permissionItem"]; + + policy::Permissions::const_iterator it_permissions = permissions.begin(); + policy::Permissions::const_iterator it_permissions_end = permissions.end(); + + for (size_t index_pi = 0; it_permissions != it_permissions_end; + ++it_permissions, ++index_pi) { + + permissions_item_array[index_pi] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& permission_item = + permissions_item_array[index_pi]; + + // Filling the rpcName of PermissionItem + permission_item["rpcName"] = (*it_permissions).first; + const policy::RpcPermissions& rpc_permissions = (*it_permissions).second; + + // Creating SO for hmiPermissions + permission_item["hmiPermissions"] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& hmi_permissions = + permission_item["hmiPermissions"]; + + policy::HMIPermissions::const_iterator it_hmi_permissions = rpc_permissions + .hmi_permissions.begin(); + policy::HMIPermissions::const_iterator it_hmi_permissions_end = + rpc_permissions.hmi_permissions.end(); + + // Filling the hmiPermissions of PermissionItem + for (; it_hmi_permissions != it_hmi_permissions_end; ++it_hmi_permissions) { + // Possible key names are "allowed", "userDisallowed" + hmi_permissions[(*it_hmi_permissions).first] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + + smart_objects::SmartObject& hmi_levels = + hmi_permissions[(*it_hmi_permissions).first]; + + std::set<policy::HMILevel>::const_iterator it_hmi_levels = + (*it_hmi_permissions).second.begin(); + std::set<policy::HMILevel>::const_iterator it_hmi_levels_end = + (*it_hmi_permissions).second.end(); + + for (size_t index_hmi_levels = 0; it_hmi_levels != it_hmi_levels_end; + ++it_hmi_levels, ++index_hmi_levels) { + hmi_levels[index_hmi_levels] = *it_hmi_levels; + } + } + + // Creating SO for parameterPermissions + permission_item["parameterPermissions"] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + + smart_objects::SmartObject& parameter_permissions = + permission_item["parameterPermissions"]; + + policy::ParameterPermissions::const_iterator it_parameter_permissions = + rpc_permissions.parameter_permissions.begin(); + policy::ParameterPermissions::const_iterator it_parameter_permissions_end = + rpc_permissions.parameter_permissions.end(); + + // Filling the parameterPermissions of PermissionItem + for (; it_parameter_permissions != it_parameter_permissions_end; + ++it_parameter_permissions) { + // Possible key names are "allowed", "userDisallowed" + parameter_permissions[(*it_parameter_permissions).first] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + + smart_objects::SmartObject& parameters = + parameter_permissions[(*it_parameter_permissions).first]; + + std::set<policy::Parameter>::const_iterator it_parameters = + (*it_parameter_permissions).second.begin(); + std::set<policy::Parameter>::const_iterator it_parameters_end = + (*it_parameter_permissions).second.end(); + + for (size_t index_parameters = 0; it_parameters != it_parameters_end; + ++it_parameters, ++index_parameters) { + parameters[index_parameters] = *it_parameters; + } + } + } + + ApplicationManagerImpl::instance()->ManageMobileCommand(notification); +} + +void MessageHelper::FillAppRevokedPermissions( + const policy::AppPermissions& permissions, + smart_objects::SmartObject& message) { + + message[strings::msg_params]["appRevokedPermissions"] = + smart_objects::SmartObject(smart_objects::SmartType_Array); + smart_objects::SmartObject& revoked_permission_items = + message[strings::msg_params]["appRevokedPermissions"]; + for (size_t i = 0; i < permissions.appRevokedPermissions.size(); ++i) { + revoked_permission_items[i] = smart_objects::SmartObject( + smart_objects::SmartType_Map); + smart_objects::SmartObject& permission_item = revoked_permission_items[i]; + permission_item["name"] = permissions.appRevokedPermissions[i]. + group_alias; + + permission_item["id"] = permissions.appRevokedPermissions[i].group_id; + + if (policy::kGroupUndefined != + permissions.appRevokedPermissions[i].state) { + permission_item["allowed"] = + policy::kGroupAllowed == permissions.appRevokedPermissions[i].state + ? true : false; + } + } +} + +void MessageHelper::SendOnAppPermissionsChangedNotification( + uint32_t connection_key, const policy::AppPermissions& permissions) { + smart_objects::SmartObject* notification = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!notification) { + return; + } + + smart_objects::SmartObject& message = *notification; + + message[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_OnAppPermissionChanged; + + message[strings::params][strings::message_type] = MessageType::kNotification; + message[strings::msg_params][strings::app_id] = connection_key; + + // TODO(AOleynik): Add other parameters processing from incoming struct + if (permissions.appRevoked) { + message[strings::msg_params]["appRevoked"] = permissions.appRevoked; + } + if (permissions.isAppPermissionsRevoked) { + message[strings::msg_params]["isAppPermissionsRevoked"] = permissions + .isAppPermissionsRevoked; + + FillAppRevokedPermissions(permissions, message); + } + + if (permissions.appPermissionsConsentNeeded) { + message[strings::msg_params]["appPermissionsConsentNeeded"] = permissions + .appPermissionsConsentNeeded; + } + if (permissions.appUnauthorized) { + message[strings::msg_params]["appUnauthorized"] = permissions + .appUnauthorized; + } + if (!permissions.priority.empty()) { + message[strings::msg_params]["priority"] = GetPriorityCode( + permissions.priority); + } + + ApplicationManagerImpl::instance()->ManageHMICommand(&message); +} + +void MessageHelper::SendGetStatusUpdateResponse(const std::string& status, + uint32_t correlation_id) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_GetStatusUpdate; + (*message)[strings::params][strings::message_type] = + MessageType::kResponse; + (*message)[strings::params][strings::correlation_id] = correlation_id; + (*message)[strings::params][hmi_response::code] = 0; + + (*message)[strings::msg_params]["status"] = status; + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +void MessageHelper::SendUpdateSDLResponse(const std::string& result, uint32_t correlation_id) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_UpdateSDL; + (*message)[strings::params][strings::message_type] = + MessageType::kResponse; + (*message)[strings::params][strings::correlation_id] = correlation_id; + (*message)[strings::params][hmi_response::code] = 0; + + (*message)[strings::msg_params]["result"] = result; + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + + + +void MessageHelper::SendOnStatusUpdate(const std::string& status) { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::SDL_OnStatusUpdate; + (*message)[strings::params][strings::message_type] = + MessageType::kNotification; + + (*message)[strings::msg_params]["status"] = status; + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +void MessageHelper::SendGetSystemInfoRequest() { + smart_objects::SmartObject* message = new smart_objects::SmartObject( + smart_objects::SmartType_Map); + if (!message) { + return; + } + + (*message)[strings::params][strings::function_id] = + hmi_apis::FunctionID::BasicCommunication_GetSystemInfo; + (*message)[strings::params][strings::message_type] = + MessageType::kRequest; + (*message)[strings::params][strings::correlation_id] = + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + (*message)[strings::params][strings::protocol_version] = + commands::CommandImpl::protocol_version_; + (*message)[strings::params][strings::protocol_type] = + commands::CommandImpl::hmi_protocol_type_; + + ApplicationManagerImpl::instance()->ManageHMICommand(message); +} + +mobile_apis::Result::eType MessageHelper::VerifyImageFiles( + smart_objects::SmartObject& message, ApplicationConstSharedPtr app) { + if (NsSmartDeviceLink::NsSmartObjects::SmartType_Array == message.getType()) { + for (uint32_t i = 0; i < message.length(); ++i) { + mobile_apis::Result::eType res = VerifyImageFiles(message[i], app); + if (mobile_apis::Result::SUCCESS != res) { + return res; + } + } + } else if (NsSmartDeviceLink::NsSmartObjects::SmartType_Map + == message.getType()) { + if (message.keyExists(strings::image_type)) { + mobile_apis::Result::eType verification_result = VerifyImage(message, + app); + + if (mobile_apis::Result::SUCCESS != verification_result) { + return verification_result; // exit point + } + } else { + std::set<std::string> keys = message.enumerate(); + + for (std::set<std::string>::const_iterator key = keys.begin(); + key != keys.end(); ++key) { + if (strings::soft_buttons != (*key)) { + mobile_apis::Result::eType res = VerifyImageFiles(message[*key], app); + if (mobile_apis::Result::SUCCESS != res) { + return res; + } + } + } + } + } // all other types shoudn't be processed + + return mobile_apis::Result::SUCCESS; +} + +mobile_apis::Result::eType MessageHelper::VerifyImage( + smart_objects::SmartObject& image, ApplicationConstSharedPtr app) { + // Checking image type first: if STATIC - skip existence check, since it is + // HMI related file and it should know it location + const uint32_t image_type = image[strings::image_type].asUInt(); + mobile_apis::ImageType::eType type = + static_cast<mobile_apis::ImageType::eType>(image_type); + if (mobile_apis::ImageType::STATIC == type) { + return mobile_apis::Result::SUCCESS; + } + + const std::string& file_name = image[strings::value].asString(); + + std::string str = file_name; + str.erase(remove(str.begin(), str.end(), ' '), str.end()); + if (0 == str.size()) { + return mobile_apis::Result::INVALID_DATA; + } + + std::string full_file_path = + profile::Profile::instance()->app_storage_folder() + "/"; + + if (file_name.size() > 0 && file_name[0] == '/') { + full_file_path = file_name; + } else { + + full_file_path += app->folder_name(); + full_file_path += "/"; + full_file_path += file_name; + } + + if (!file_system::FileExists(full_file_path)) { + return mobile_apis::Result::INVALID_DATA; + } + + image[strings::value] = full_file_path; + + return mobile_apis::Result::SUCCESS; +} + +mobile_apis::Result::eType MessageHelper::VerifyImageVrHelpItems( + smart_objects::SmartObject& message, ApplicationConstSharedPtr app) { + mobile_apis::Result::eType verification_result_image = + mobile_apis::Result::SUCCESS; + for (uint32_t i = 0; i < message.length(); ++i) { + if (message[i].keyExists(strings::image)) { + verification_result_image = VerifyImage(message[i][strings::image], app); + if (mobile_apis::Result::SUCCESS != verification_result_image) { + return verification_result_image; + } + } + } + return mobile_apis::Result::SUCCESS; +} + +bool MessageHelper::VerifySoftButtonString(const std::string& str) { + + if ((std::string::npos != str.find_first_of("\t\n")) || + (std::string::npos != str.find("\\n")) || + (std::string::npos != str.find("\\t")) || + (std::string::npos == str.find_first_not_of(' '))) { + LOG4CXX_ERROR(logger_, "MessageHelper::VerifySoftButtonString" + "string contains incorrect character"); + return false; + } + return true; +} + +mobile_apis::Result::eType MessageHelper::ProcessSoftButtons( + smart_objects::SmartObject& message_params, ApplicationConstSharedPtr app) { + if (!message_params.keyExists(strings::soft_buttons)) { + return mobile_apis::Result::SUCCESS; + } + + const HMICapabilities& hmi_capabilities = ApplicationManagerImpl::instance() + ->hmi_capabilities(); + const smart_objects::SmartObject* soft_button_capabilities = hmi_capabilities + .soft_button_capabilities(); + bool image_supported = false; + if (soft_button_capabilities) { + image_supported = (*soft_button_capabilities)[hmi_response::image_supported] + .asBool(); + } + + smart_objects::SmartObject& request_soft_buttons = + message_params[strings::soft_buttons]; + + // Check whether soft buttons request is well-formed + if (!ValidateSoftButtons(request_soft_buttons)) { + return mobile_apis::Result::INVALID_DATA; + } + + smart_objects::SmartObject soft_buttons = smart_objects::SmartObject( + smart_objects::SmartType_Array); + + policy::PolicyHandler* policy_handler = policy::PolicyHandler::instance(); + std::string app_mobile_id = app->mobile_app_id()->asString(); + + uint32_t j = 0; + size_t size = request_soft_buttons.length(); + for (uint32_t i = 0; i < size; ++i) { + int system_action = request_soft_buttons[i][strings::system_action].asInt(); + if (!policy_handler->CheckKeepContext(system_action, app_mobile_id) || + !policy_handler->CheckStealFocus(system_action, app_mobile_id)) { + return mobile_apis::Result::DISALLOWED; + } + + switch (request_soft_buttons[i][strings::type].asInt()) { + case mobile_apis::SoftButtonType::SBT_IMAGE: { + if (!image_supported) { + continue; + } + //Any text value for type "IMAGE" should be ignored. + if (request_soft_buttons[i].keyExists(strings::text)) { + request_soft_buttons[i].erase(strings::text); + } + if (request_soft_buttons[i].keyExists(strings::image)) { + mobile_apis::Result::eType verification_result = VerifyImage( + request_soft_buttons[i][strings::image], app); + if (mobile_apis::Result::SUCCESS != verification_result) { + return mobile_apis::Result::INVALID_DATA; + } + } else { + return mobile_apis::Result::INVALID_DATA; + } + break; + } + case mobile_apis::SoftButtonType::SBT_TEXT: { + if ((!request_soft_buttons[i].keyExists(strings::text)) || + (!VerifySoftButtonString( + request_soft_buttons[i][strings::text].asString()))) { + return mobile_apis::Result::INVALID_DATA; + } + break; + } + case mobile_apis::SoftButtonType::SBT_BOTH: { + + if ((!request_soft_buttons[i].keyExists(strings::text)) || + ((request_soft_buttons[i][strings::text].length()) + && (!VerifySoftButtonString( + request_soft_buttons[i][strings::text].asString())))) { + return mobile_apis::Result::INVALID_DATA; + } + + bool image_exist = false; + if (image_supported) { + image_exist = request_soft_buttons[i].keyExists(strings::image); + if (!image_exist) { + return mobile_apis::Result::INVALID_DATA; + } + } + if (image_exist) { + mobile_apis::Result::eType verification_result = VerifyImage( + request_soft_buttons[i][strings::image], app); + + if (mobile_apis::Result::SUCCESS != verification_result) { + return mobile_apis::Result::INVALID_DATA; + + } + } + break; + } + default: { + continue; + break; + } + } + + soft_buttons[j] = request_soft_buttons[i]; + ++j; + } + + request_soft_buttons = soft_buttons; + + if (0 == request_soft_buttons.length()) { + message_params.erase(strings::soft_buttons); + } + return mobile_apis::Result::SUCCESS; +} + +void MessageHelper::SubscribeApplicationToSoftButton( + smart_objects::SmartObject& message_params, ApplicationSharedPtr app, + int32_t function_id) { + SoftButtonID softbuttons_id; + smart_objects::SmartObject& soft_buttons = message_params[strings::soft_buttons]; + unsigned int length = soft_buttons.length(); + for(unsigned int i = 0; i < length; ++i) { + softbuttons_id.insert(soft_buttons[i][strings::soft_button_id].asUInt()); + } + app->SubscribeToSoftButtons(function_id, softbuttons_id); +} + +// TODO(AK): change printf to logger +bool MessageHelper::PrintSmartObject(const smart_objects::SmartObject& object) { + return true; +#ifdef ENABLE_LOG + static uint32_t tab = 0; + std::string tab_buffer; + + if (tab == 0) { + printf("\n-------------------------------------------------------------"); + } + + for (uint32_t i = 0; i < tab; ++i) { + tab_buffer += "\t"; + } + + switch (object.getType()) { + case NsSmartDeviceLink::NsSmartObjects::SmartType_Array: { + for (size_t i = 0; i < object.length(); i++) { + ++tab; + + printf("\n%s%zu: ", tab_buffer.c_str(), i); + if (!PrintSmartObject(object.getElement(i))) { + printf("\n"); + return false; + } + } + break; + } + case NsSmartDeviceLink::NsSmartObjects::SmartType_Map: { + std::set<std::string> keys = object.enumerate(); + + for (std::set<std::string>::const_iterator key = keys.begin(); + key != keys.end(); key++) { + ++tab; + + printf("\n%s%s: ", tab_buffer.c_str(), (*key).c_str()); + if (!PrintSmartObject(object[(*key).c_str()])) { + printf("\n"); + return false; + } + } + break; + } + case NsSmartDeviceLink::NsSmartObjects::SmartType_Boolean: + object.asBool() ? printf("true\n") : printf("false\n"); + break; + case NsSmartDeviceLink::NsSmartObjects::SmartType_Double: { + printf("%f", object.asDouble()); + break; + } + case NsSmartDeviceLink::NsSmartObjects::SmartType_Integer: + printf("%" PRId64 "\n", object.asInt64()); + break; + case NsSmartDeviceLink::NsSmartObjects::SmartType_String: + printf("%s", object.asString().c_str()); + break; + case NsSmartDeviceLink::NsSmartObjects::SmartType_Character: + printf("%c", object.asChar()); + break; + default: + printf("PrintSmartObject - default case\n"); + break; + } + + if (0 != tab) { + --tab; + } else { + printf("\n-------------------------------------------------------------\n"); + } +#endif + return true; +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/mobile_command_factory.cc b/src/components/application_manager/src/mobile_command_factory.cc new file mode 100644 index 0000000000..2d2e31f735 --- /dev/null +++ b/src/components/application_manager/src/mobile_command_factory.cc @@ -0,0 +1,549 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/mobile_command_factory.h" +#include "application_manager/commands/mobile/add_command_request.h" +#include "application_manager/commands/mobile/add_command_response.h" +#include "application_manager/commands/mobile/delete_command_request.h" +#include "application_manager/commands/mobile/delete_command_response.h" +#include "application_manager/commands/mobile/add_sub_menu_request.h" +#include "application_manager/commands/mobile/add_sub_menu_response.h" +#include "application_manager/commands/mobile/alert_request.h" +#include "application_manager/commands/mobile/alert_response.h" +#include "application_manager/commands/mobile/alert_maneuver_request.h" +#include "application_manager/commands/mobile/alert_maneuver_response.h" +#include "application_manager/commands/mobile/change_registration_request.h" +#include "application_manager/commands/mobile/change_registration_response.h" +#include "application_manager/commands/mobile/create_interaction_choice_set_request.h" +#include "application_manager/commands/mobile/create_interaction_choice_set_response.h" +#include "application_manager/commands/mobile/delete_file_request.h" +#include "application_manager/commands/mobile/delete_file_response.h" +#include "application_manager/commands/mobile/delete_interaction_choice_set_request.h" +#include "application_manager/commands/mobile/delete_interaction_choice_set_response.h" +#include "application_manager/commands/mobile/delete_sub_menu_request.h" +#include "application_manager/commands/mobile/delete_sub_menu_response.h" +#include "application_manager/commands/mobile/dial_number_request.h" +#include "application_manager/commands/mobile/end_audio_pass_thru_request.h" +#include "application_manager/commands/mobile/end_audio_pass_thru_response.h" +#include "application_manager/commands/mobile/generic_response.h" +#include "application_manager/commands/mobile/get_dtcs_request.h" +#include "application_manager/commands/mobile/get_dtcs_response.h" +#include "application_manager/commands/mobile/get_vehicle_data_request.h" +#include "application_manager/commands/mobile/get_vehicle_data_response.h" +#include "application_manager/commands/mobile/list_files_request.h" +#include "application_manager/commands/mobile/list_files_response.h" +#include "application_manager/commands/mobile/on_app_interface_unregistered_notification.h" +#include "application_manager/commands/mobile/on_audio_pass_thru_notification.h" +#include "application_manager/commands/mobile/on_button_event_notification.h" +#include "application_manager/commands/mobile/on_button_press_notification.h" +#include "application_manager/commands/mobile/on_driver_distraction_notification.h" +#include "application_manager/commands/mobile/on_hmi_status_notification.h" +#include "application_manager/commands/mobile/on_language_change_notification.h" +#include "application_manager/commands/mobile/on_command_notification.h" +#include "application_manager/commands/mobile/on_permissions_change_notification.h" +#include "application_manager/commands/mobile/on_tbt_client_state_notification.h" +#include "application_manager/commands/mobile/on_vehicle_data_notification.h" +#include "application_manager/commands/mobile/on_hash_change_notification.h" +#include "application_manager/commands/mobile/perform_audio_pass_thru_request.h" +#include "application_manager/commands/mobile/perform_audio_pass_thru_response.h" +#include "application_manager/commands/mobile/perform_interaction_request.h" +#include "application_manager/commands/mobile/perform_interaction_response.h" +#include "application_manager/commands/mobile/put_file_request.h" +#include "application_manager/commands/mobile/put_file_response.h" +#include "application_manager/commands/mobile/read_did_request.h" +#include "application_manager/commands/mobile/read_did_response.h" +#include "application_manager/commands/mobile/register_app_interface_request.h" +#include "application_manager/commands/mobile/register_app_interface_response.h" +#include "application_manager/commands/mobile/reset_global_properties_request.h" +#include "application_manager/commands/mobile/reset_global_properties_response.h" +#include "application_manager/commands/mobile/scrollable_message_request.h" +#include "application_manager/commands/mobile/scrollable_message_response.h" +#include "application_manager/commands/mobile/set_display_layout_request.h" +#include "application_manager/commands/mobile/set_display_layout_response.h" +#include "application_manager/commands/mobile/set_global_properties_request.h" +#include "application_manager/commands/mobile/set_global_properties_response.h" +#include "application_manager/commands/mobile/set_icon_request.h" +#include "application_manager/commands/mobile/set_icon_response.h" +#include "application_manager/commands/mobile/set_media_clock_timer_request.h" +#include "application_manager/commands/mobile/set_media_clock_timer_response.h" +#include "application_manager/commands/mobile/show_constant_tbt_request.h" +#include "application_manager/commands/mobile/show_constant_tbt_response.h" +#include "application_manager/commands/mobile/show_request.h" +#include "application_manager/commands/mobile/show_response.h" +#include "application_manager/commands/mobile/slider_request.h" +#include "application_manager/commands/mobile/slider_response.h" +#include "application_manager/commands/mobile/speak_request.h" +#include "application_manager/commands/mobile/speak_response.h" +#include "application_manager/commands/mobile/subscribe_button_request.h" +#include "application_manager/commands/mobile/subscribe_button_response.h" +#include "application_manager/commands/mobile/subscribe_vehicle_data_request.h" +#include "application_manager/commands/mobile/subscribe_vehicle_data_response.h" +#include "application_manager/commands/mobile/unregister_app_interface_request.h" +#include "application_manager/commands/mobile/unregister_app_interface_response.h" +#include "application_manager/commands/mobile/unsubscribe_button_request.h" +#include "application_manager/commands/mobile/unsubscribe_button_response.h" +#include "application_manager/commands/mobile/unsubscribe_vehicle_data_request.h" +#include "application_manager/commands/mobile/unsubscribe_vehicle_data_response.h" +#include "application_manager/commands/mobile/update_turn_list_request.h" +#include "application_manager/commands/mobile/update_turn_list_response.h" +#include "application_manager/commands/mobile/system_request.h" +#include "application_manager/commands/mobile/system_response.h" +#include "application_manager/commands/mobile/on_keyboard_input_notification.h" +#include "application_manager/commands/mobile/on_touch_event_notification.h" +#include "application_manager/commands/mobile/on_system_request_notification.h" +#include "application_manager/commands/mobile/diagnostic_message_request.h" +#include "application_manager/commands/mobile/diagnostic_message_response.h" +#include "application_manager/commands/mobile/send_location_request.h" +#include "application_manager/commands/mobile/send_location_response.h" +#include "interfaces/MOBILE_API.h" + +namespace application_manager { + +commands::Command *MobileCommandFactory::CreateCommand( + const MessageSharedPtr& message) { + + switch ((*message)[strings::params][strings::function_id].asInt()) { + case mobile_apis::FunctionID::RegisterAppInterfaceID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kRequest)) { + return new commands::RegisterAppInterfaceRequest(message); + } else { + return new commands::RegisterAppInterfaceResponse(message); + } + break; + } + case mobile_apis::FunctionID::UnregisterAppInterfaceID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kRequest)) { + return new commands::UnregisterAppInterfaceRequest(message); + } else { + return new commands::UnregisterAppInterfaceResponse(message); + } + break; + } + case mobile_apis::FunctionID::SetGlobalPropertiesID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SetGlobalPropertiesResponse(message); + } else { + return new commands::SetGlobalPropertiesRequest(message); + } + break; + } + case mobile_apis::FunctionID::ResetGlobalPropertiesID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ResetGlobalPropertiesResponse(message); + } else { + return new commands::ResetGlobalPropertiesRequest(message); + } + break; + } + case mobile_apis::FunctionID::AddCommandID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::AddCommandResponse(message); + } else { + return new commands::AddCommandRequest(message); + } + break; + } + case mobile_apis::FunctionID::DeleteCommandID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::DeleteCommandResponse(message); + } else { + return new commands::DeleteCommandRequest(message); + } + break; + } + case mobile_apis::FunctionID::AddSubMenuID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::AddSubMenuResponse(message); + } else { + return new commands::AddSubMenuRequest(message); + } + break; + } + case mobile_apis::FunctionID::DeleteSubMenuID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::DeleteSubMenuResponse(message); + } else { + return new commands::DeleteSubMenuRequest(message); + } + break; + } + case mobile_apis::FunctionID::DeleteInteractionChoiceSetID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return + new commands::DeleteInteractionChoiceSetResponse(message); + } else { + return new commands::DeleteInteractionChoiceSetRequest(message); + } + break; + } + case mobile_apis::FunctionID::AlertID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::AlertResponse(message); + } else { + return new commands::AlertRequest(message); + } + break; + } + case mobile_apis::FunctionID::SpeakID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SpeakResponse(message); + } else { + return new commands::SpeakRequest(message); + } + break; + } + case mobile_apis::FunctionID::SliderID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SliderResponse(message); + } else { + return new commands::SliderRequest(message); + } + break; + } + case mobile_apis::FunctionID::PerformAudioPassThruID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::PerformAudioPassThruResponse(message); + } else { + return new commands::PerformAudioPassThruRequest(message); + } + break; + } + case mobile_apis::FunctionID::CreateInteractionChoiceSetID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return + new commands::CreateInteractionChoiceSetResponse(message); + } else { + return new commands::CreateInteractionChoiceSetRequest(message); + } + break; + } + case mobile_apis::FunctionID::PerformInteractionID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::PerformInteractionResponse(message); + } else { + return new commands::PerformInteractionRequest(message); + } + break; + } + case mobile_apis::FunctionID::EndAudioPassThruID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::EndAudioPassThruResponse(message); + } else { + return new commands::EndAudioPassThruRequest(message); + } + break; + } + case mobile_apis::FunctionID::PutFileID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::PutFileResponse(message); + } else { + return new commands::PutFileRequest(message); + } + break; + } + case mobile_apis::FunctionID::DeleteFileID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::DeleteFileResponse(message); + } else { + return new commands::DeleteFileRequest(message); + } + break; + } + case mobile_apis::FunctionID::ListFilesID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ListFilesResponse(message); + } else { + return new commands::ListFilesRequest(message); + } + break; + } + case mobile_apis::FunctionID::SubscribeButtonID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SubscribeButtonResponse(message); + } else { + return new commands::SubscribeButtonRequest(message); + } + break; + } + case mobile_apis::FunctionID::UnsubscribeButtonID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::UnsubscribeButtonResponse(message); + } else { + return new commands::UnsubscribeButtonRequest(message); + } + break; + } + case mobile_apis::FunctionID::ShowConstantTBTID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ShowConstantTBTResponse(message); + } else { + return new commands::ShowConstantTBTRequest(message); + } + break; + } + case mobile_apis::FunctionID::ShowID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ShowResponse(message); + } else { + return new commands::ShowRequest(message); + } + break; + } + case mobile_apis::FunctionID::SubscribeVehicleDataID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SubscribeVehicleDataResponse(message); + } else { + return new commands::SubscribeVehicleDataRequest(message); + } + break; + } + case mobile_apis::FunctionID::UnsubscribeVehicleDataID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::UnsubscribeVehicleDataResponse(message); + } else { + return new commands::UnsubscribeVehicleDataRequest(message); + } + break; + } + case mobile_apis::FunctionID::ReadDIDID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ReadDIDResponse(message); + } else { + return new commands::ReadDIDRequest(message); + } + break; + } + case mobile_apis::FunctionID::GetVehicleDataID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::GetVehicleDataResponse(message); + } else { + return new commands::GetVehicleDataRequest(message); + } + break; + } + case mobile_apis::FunctionID::ScrollableMessageID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ScrollableMessageResponse(message); + } else { + return new commands::ScrollableMessageRequest(message); + } + break; + } + case mobile_apis::FunctionID::AlertManeuverID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::AlertManeuverResponse(message); + } else { + return new commands::AlertManeuverRequest(message); + } + break; + } + case mobile_apis::FunctionID::SetAppIconID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SetIconResponse(message); + } else { + return new commands::SetIconRequest(message); + } + break; + } + case mobile_apis::FunctionID::SetDisplayLayoutID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SetDisplayLayoutResponse(message); + } else { + return new commands::SetDisplayLayoutRequest(message); + } + break; + } + case mobile_apis::FunctionID::UpdateTurnListID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::UpdateTurnListResponse(message); + } else { + return new commands::UpdateTurnListRequest(message); + } + break; + } + case mobile_apis::FunctionID::ChangeRegistrationID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::ChangeRegistrationResponse(message); + } else { + return new commands::ChangeRegistrationRequest(message); + } + break; + } + case mobile_apis::FunctionID::GetDTCsID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::GetDTCsResponse(message); + } else { + return new commands::GetDTCsRequest(message); + } + break; + } + case mobile_apis::FunctionID::DiagnosticMessageID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::DiagnosticMessageResponse(message); + } else { + return new commands::DiagnosticMessageRequest(message); + } + break; + } + case mobile_apis::FunctionID::SetMediaClockTimerID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SetMediaClockTimerResponse(message); + } else { + return new commands::SetMediaClockRequest(message); + } + break; + } + case mobile_apis::FunctionID::SystemRequestID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SystemResponse(message); + } else { + return new commands::SystemRequest(message); + } + break; + } + case mobile_apis::FunctionID::SendLocationID: { + if ((*message)[strings::params][strings::message_type] + == static_cast<int>(application_manager::MessageType::kResponse)) { + return new commands::SendLocationResponse(message); + } else { + return new commands::SendLocationRequest(message); + } + break; + } + case mobile_apis::FunctionID::OnButtonEventID: { + return new commands::mobile::OnButtonEventNotification(message); + break; + } + case mobile_apis::FunctionID::OnButtonPressID: { + return new commands::mobile::OnButtonPressNotification(message); + break; + } + case mobile_apis::FunctionID::OnAudioPassThruID: { + return new commands::OnAudioPassThruNotification(message); + break; + } + case mobile_apis::FunctionID::OnVehicleDataID: { + return new commands::OnVehicleDataNotification(message); + break; + } + case mobile_apis::FunctionID::OnAppInterfaceUnregisteredID: { + return + new commands::OnAppInterfaceUnregisteredNotification(message); + break; + } + case mobile_apis::FunctionID::OnCommandID: { + return new commands::OnCommandNotification(message); + break; + } + case mobile_apis::FunctionID::OnTBTClientStateID: { + return new commands::OnTBTClientStateNotification(message); + break; + } + case mobile_apis::FunctionID::OnDriverDistractionID: { + return + new commands::mobile::OnDriverDistractionNotification(message); + break; + } + case mobile_apis::FunctionID::OnLanguageChangeID: { + return new commands::OnLanguageChangeNotification(message); + break; + } + case mobile_apis::FunctionID::OnPermissionsChangeID: { + return new commands::OnPermissionsChangeNotification(message); + break; + } + case mobile_apis::FunctionID::OnHMIStatusID: { + return new commands::OnHMIStatusNotification(message); + break; + } + case mobile_apis::FunctionID::OnKeyboardInputID: { + return new commands::mobile::OnKeyBoardInputNotification(message); + break; + } + case mobile_apis::FunctionID::OnTouchEventID: { + return new commands::mobile::OnTouchEventNotification(message); + break; + } + case mobile_apis::FunctionID::OnSystemRequestID: { + return new commands::mobile::OnSystemRequestNotification(message); + break; + } + case mobile_apis::FunctionID::OnHashChangeID: { + return new commands::mobile::OnHashChangeNotification(message); + break; + } + default: { + (*message)[strings::params][strings::function_id] = + static_cast<int32_t>(mobile_apis::FunctionID::GenericResponseID); + return new commands::GenericResponse(message); + } + } +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/mobile_message_handler.cc b/src/components/application_manager/src/mobile_message_handler.cc new file mode 100644 index 0000000000..e2293e3816 --- /dev/null +++ b/src/components/application_manager/src/mobile_message_handler.cc @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 <string.h> + +#include "utils/macro.h" +#include "application_manager/mobile_message_handler.h" +#include "protocol_handler/protocol_payload.h" +#include "protocol_handler/protocol_packet.h" +#include "utils/bitstream.h" +#include "utils/logger.h" + +#include <stdint.h> +#include <memory> + +namespace { +const uint8_t kRequest = 0x0; +const uint8_t kResponse = 0x1; +const uint8_t kNotification = 0x2; +const uint8_t kUnknown = 0xF; +} + +namespace application_manager { + +CREATE_LOGGERPTR_GLOBAL(logger_, "MobileMessageHandler") + + +application_manager::Message* +MobileMessageHandler::HandleIncomingMessageProtocolV1( + const RawMessagePtr message) { + LOG4CXX_INFO(logger_, + "MobileMessageHandler HandleIncomingMessageProtocolV1()"); + application_manager::Message* outgoing_message = + new application_manager::Message( + protocol_handler::MessagePriority::FromServiceType( + message->service_type()) + ); + if (!message) { + NOTREACHED(); + return NULL; + } + + outgoing_message->set_connection_key(message->connection_key()); + outgoing_message->set_protocol_version( + static_cast<application_manager::ProtocolVersion>(message + ->protocol_version())); + outgoing_message->set_json_message( + std::string(reinterpret_cast<const char*>(message->data()), + message->data_size())); + + if (outgoing_message->json_message().empty()) { + return NULL; + } + + return outgoing_message; +} + +application_manager::Message* +MobileMessageHandler::HandleIncomingMessageProtocolV2( + const RawMessagePtr message) { + LOG4CXX_INFO(logger_, + "MobileMessageHandler HandleIncomingMessageProtocolV2()"); + + utils::BitStream message_bytestream(message->data(), message->data_size()); + protocol_handler::ProtocolPayloadV2 payload; + protocol_handler::Extract(&message_bytestream, &payload, + message->data_size()); + + // Silently drop message if it wasn't parsed correctly + if (message_bytestream.IsBad()) { + LOG4CXX_WARN(logger_, + "Drop ill-formed message from mobile, partially parsed: " + << payload); + return NULL; + } + + std::auto_ptr<application_manager::Message> outgoing_message( + new application_manager::Message( + protocol_handler::MessagePriority::FromServiceType( + message->service_type()))); + + outgoing_message->set_json_message(payload.json); + outgoing_message->set_function_id(payload.header.rpc_function_id); + outgoing_message->set_message_type( + MessageTypeFromRpcType(payload.header.rpc_type)); + outgoing_message->set_correlation_id(int32_t(payload.header.corellation_id)); + outgoing_message->set_connection_key(message->connection_key()); + outgoing_message->set_protocol_version( + static_cast<application_manager::ProtocolVersion>(message + ->protocol_version())); + outgoing_message->set_data_size(message->data_size()); + outgoing_message->set_payload_size(message->payload_size()); + + if (!payload.data.empty()) { + outgoing_message->set_binary_data( + new application_manager::BinaryData(payload.data)); + } + return outgoing_message.release(); +} + +protocol_handler::RawMessage* +MobileMessageHandler::HandleOutgoingMessageProtocolV1( + const MobileMessage& message) { + LOG4CXX_INFO(logger_, + "MobileMessageHandler HandleOutgoingMessageProtocolV1()"); + std::string messageString = message->json_message(); + if (messageString.length() == 0) { + LOG4CXX_INFO(logger_, + "Drop ill-formed message from mobile"); + return NULL; + } + + uint8_t* rawMessage = new uint8_t[messageString.length() + 1]; + memcpy(rawMessage, messageString.c_str(), messageString.length() + 1); + + protocol_handler::RawMessage* result = new protocol_handler::RawMessage( + message->connection_key(), 1, rawMessage, messageString.length() + 1); + + return result; +} + +protocol_handler::RawMessage* +MobileMessageHandler::HandleOutgoingMessageProtocolV2( + const MobileMessage& message) { + LOG4CXX_INFO(logger_, + "MobileMessageHandler HandleOutgoingMessageProtocolV2()"); + if (message->json_message().length() == 0) { + LOG4CXX_ERROR(logger_, "json string is empty."); + } + uint32_t jsonSize = message->json_message().length(); + uint32_t binarySize = 0; + if (message->has_binary_data()) { + binarySize = message->binary_data()->size(); + } + + const size_t dataForSendingSize = + protocol_handler::PROTOCOL_HEADER_V2_SIZE + jsonSize + binarySize; + uint8_t* dataForSending = new uint8_t[dataForSendingSize]; + uint8_t offset = 0; + + uint8_t rpcTypeFlag = 0; + switch (message->type()) { + case application_manager::kRequest: + rpcTypeFlag = kRequest; + break; + case application_manager::kResponse: + rpcTypeFlag = kResponse; + break; + case application_manager::kNotification: + rpcTypeFlag = kNotification; + break; + default: + NOTREACHED(); + break; + } + + uint32_t functionId = message->function_id(); + dataForSending[offset++] = ((rpcTypeFlag << 4) & 0xF0) | (functionId >> 24); + dataForSending[offset++] = functionId >> 16; + dataForSending[offset++] = functionId >> 8; + dataForSending[offset++] = functionId; + + uint32_t correlationId = message->correlation_id(); + dataForSending[offset++] = correlationId >> 24; + dataForSending[offset++] = correlationId >> 16; + dataForSending[offset++] = correlationId >> 8; + dataForSending[offset++] = correlationId; + + dataForSending[offset++] = jsonSize >> 24; + dataForSending[offset++] = jsonSize >> 16; + dataForSending[offset++] = jsonSize >> 8; + dataForSending[offset++] = jsonSize; + + memcpy(dataForSending + offset, message->json_message().c_str(), jsonSize); + + if (message->has_binary_data()) { + const std::vector<uint8_t>& binaryData = *(message->binary_data()); + uint8_t* currentPointer = dataForSending + offset + jsonSize; + for (uint32_t i = 0; i < binarySize; ++i) { + currentPointer[i] = binaryData[i]; + } + } + + protocol_handler::RawMessage* msgToProtocolHandler = + new protocol_handler::RawMessage(message->connection_key(), + message->protocol_version(), + dataForSending, + dataForSendingSize); + + return msgToProtocolHandler; +} +} // namespace application_manager diff --git a/src/components/application_manager/src/policies/policy_event_observer.cc b/src/components/application_manager/src/policies/policy_event_observer.cc new file mode 100644 index 0000000000..e7b259e6b5 --- /dev/null +++ b/src/components/application_manager/src/policies/policy_event_observer.cc @@ -0,0 +1,104 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/policies/policy_event_observer.h" +#include "application_manager/smart_object_keys.h" +#include "utils/date_time.h" +#include "policy/policy_manager.h" +#include "smart_objects/smart_object.h" + +namespace policy { +namespace smart_objects = NsSmartDeviceLink::NsSmartObjects; +using namespace application_manager; + +PolicyEventObserver::PolicyEventObserver(utils::SharedPtr<PolicyManager> policy_manager) + : policy_manager_(policy_manager) { +} + +void PolicyEventObserver::on_event(const event_engine::Event& event) { + if (policy_manager_.valid()) { + return; + } + const smart_objects::SmartObject& message = event.smart_object(); + + switch (event.id()) { +#ifdef HMI_DBUS_API + case hmi_apis::FunctionID::VehicleInfo_GetOdometer: { + ProcessOdometerEvent(message); + break; + } + default: { + break; + } + unsubscribe_from_event(hmi_apis::FunctionID::VehicleInfo_GetOdometer); +#else + case hmi_apis::FunctionID::VehicleInfo_GetVehicleData: { + ProcessOdometerEvent(message); + unsubscribe_from_event(hmi_apis::FunctionID::VehicleInfo_GetVehicleData); + break; + } + case hmi_apis::FunctionID::BasicCommunication_OnReady: { + policy_manager_->OnSystemReady(); + unsubscribe_from_event(hmi_apis::FunctionID::BasicCommunication_OnReady); + break; + } + default: { + break; + } +#endif + } +} + +void PolicyEventObserver::ProcessOdometerEvent(const smart_objects::SmartObject& message) { + if (hmi_apis::Common_Result::SUCCESS + == static_cast<hmi_apis::Common_Result::eType>(message[strings::params][hmi_response::code] + .asInt())) { + + if (message[strings::msg_params].keyExists(strings::odometer)) { + TimevalStruct current_time = date_time::DateTime::getCurrentTime(); + const int kSecondsInDay = 60 * 60 * 24; + int days_after_epoch = current_time.tv_sec / kSecondsInDay; + + if(policy_manager_) { + policy_manager_->PTUpdatedAt( + message[strings::msg_params][strings::odometer].asInt(), + days_after_epoch); + } + } + } +} + +void PolicyEventObserver::subscribe_on_event( + const event_engine::Event::EventID& event_id, int32_t hmi_correlation_id) { + event_engine::EventObserver::subscribe_on_event(event_id, hmi_correlation_id); +} +} // namespace policy diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc new file mode 100644 index 0000000000..ea1045247a --- /dev/null +++ b/src/components/application_manager/src/policies/policy_handler.cc @@ -0,0 +1,1319 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 <unistd.h> +#include <dlfcn.h> +#include <algorithm> +#include <vector> +#include "application_manager/smart_object_keys.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/policies/pt_exchange_handler_impl.h" +#include "application_manager/policies/pt_exchange_handler_ext.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/message_helper.h" +#include "policy/policy_manager_impl.h" +#include "connection_handler/connection_handler.h" +#include "utils/macro.h" +#include "utils/date_time.h" +#include "json/value.h" +#include "json/writer.h" +#include "config_profile/profile.h" +#include "application_manager/usage_statistics.h" +#include "policy/policy_types.h" +#include "interfaces/MOBILE_API.h" + +namespace policy { + +#define POLICY_LIB_CHECK(return_value) {\ + if (!policy_manager_) {\ + LOG4CXX_WARN(logger_, "The shared library of policy is not loaded");\ + return return_value;\ + }\ +} + +#define POLICY_LIB_CHECK_VOID() {\ + if (!policy_manager_) {\ + LOG4CXX_WARN(logger_, "The shared library of policy is not loaded");\ + return;\ + }\ +} + +CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler") + +typedef std::set<application_manager::ApplicationSharedPtr> ApplicationList; + +struct DeactivateApplication { + explicit DeactivateApplication( + const connection_handler::DeviceHandle& device_id) + : device_id_(device_id) {} + + void operator()(const application_manager::ApplicationSharedPtr& app) { + if (device_id_ == app->device()) { + app->set_hmi_level(mobile_apis::HMILevel::HMI_NONE); + application_manager::MessageHelper::SendActivateAppToHMI( + app->app_id(), hmi_apis::Common_HMILevel::NONE); + } + } + + private: + connection_handler::DeviceHandle device_id_; +}; + +struct SDLAlowedNotification { + explicit SDLAlowedNotification( + const connection_handler::DeviceHandle& device_id, + utils::SharedPtr<PolicyManager> policy_manager) + : device_id_(device_id), + policy_manager_(policy_manager){} + + void operator()(const application_manager::ApplicationSharedPtr& app) { + if (!policy_manager_) { + return; + } + if (device_id_ == app->device()) { + std::string hmi_level; + hmi_apis::Common_HMILevel::eType default_hmi; + mobile_apis::HMILevel::eType default_mobile_hmi; + policy_manager_->GetDefaultHmi(app->mobile_app_id()->asString(), &hmi_level); + if ("BACKGROUND" == hmi_level) { + default_hmi = hmi_apis::Common_HMILevel::BACKGROUND; + default_mobile_hmi = mobile_apis::HMILevel::HMI_BACKGROUND; + } else if ("FULL" == hmi_level) { + default_hmi = hmi_apis::Common_HMILevel::FULL; + default_mobile_hmi = mobile_apis::HMILevel::HMI_FULL; + } else if ("LIMITED" == hmi_level) { + default_hmi = hmi_apis::Common_HMILevel::LIMITED; + default_mobile_hmi = mobile_apis::HMILevel::HMI_LIMITED; + } else if ("NONE" == hmi_level) { + default_hmi = hmi_apis::Common_HMILevel::NONE; + default_mobile_hmi = mobile_apis::HMILevel::HMI_NONE; + } else { + return ; + } + if (app->hmi_level() == default_mobile_hmi) { + LOG4CXX_INFO(logger_, "Application already in default hmi state."); + } else { + app->set_hmi_level(default_mobile_hmi); + application_manager::MessageHelper::SendHMIStatusNotification(*app); + } + application_manager::MessageHelper::SendActivateAppToHMI(app->app_id(), default_hmi); + } + } + private: + connection_handler::DeviceHandle device_id_; + utils::SharedPtr<PolicyManager> policy_manager_; +}; + +struct LinkAppToDevice { + explicit LinkAppToDevice( + std::map<std::string, std::string>& app_to_device_link) + : app_to_device_link_(app_to_device_link) { + app_to_device_link_.clear(); + } + + void operator()(const application_manager::ApplicationSharedPtr& app) { + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Invalid pointer to application was passed." + "Skip current application."); + return; + } + DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForApp( + app->app_id(), + &device_params); + const std::string app_id = app->mobile_app_id()->asString(); + if (device_params.device_mac_address.empty()) { + LOG4CXX_WARN(logger_, "Couldn't find device, which hosts application " + << app_id); + return; + } + app_to_device_link_[app_id] = device_params.device_mac_address; + } + +private: + std::map<std::string, std::string>& app_to_device_link_; +}; + +struct PermissionsConsolidator { + void Consolidate( + const std::vector<policy::FunctionalGroupPermission>& permissions) { + std::vector<policy::FunctionalGroupPermission>::const_iterator it = + permissions.begin(); + std::vector<policy::FunctionalGroupPermission>::const_iterator it_end = + permissions.end(); + for (;it != it_end; ++it) { + std::vector<policy::FunctionalGroupPermission>::iterator it_consolidated = + std::find(consolidated_permissions_.begin(), + consolidated_permissions_.end(), + *it); + + // If found, consolidate states + if (consolidated_permissions_.end() != it_consolidated) { + if (policy::kGroupAllowed == it->state || + policy::kGroupAllowed == it_consolidated->state) { + it_consolidated->state = policy::kGroupAllowed; + } else if (policy::kGroupDisallowed == it->state || + policy::kGroupDisallowed == it_consolidated->state) { + it_consolidated->state = policy::kGroupDisallowed; + } + continue; + } + + // If not found, add permissions + consolidated_permissions_.push_back(*it); + } + } + + const std::vector<policy::FunctionalGroupPermission>& + GetConsolidatedPermissions() const { + return consolidated_permissions_; + } + +private: + std::vector<policy::FunctionalGroupPermission> consolidated_permissions_; +}; + +PolicyHandler* PolicyHandler::instance_ = NULL; +const std::string PolicyHandler::kLibrary = "libPolicy.so"; + +PolicyHandler::PolicyHandler() + : dl_handle_(0), +// EXTENDED_POLICY + exchange_handler_(new PTExchangeHandlerImpl(this)), + on_ignition_check_done_(false), + last_activated_app_id_(0), + registration_in_progress(false), + is_user_requested_policy_table_update_(false) { +} + +PolicyHandler::~PolicyHandler() { + +} + +bool PolicyHandler::LoadPolicyLibrary() { + if (!PolicyEnabled()) { + LOG4CXX_WARN(logger_, "System is configured to work without policy " + "functionality."); + policy_manager_ = NULL; + return NULL; + } + dl_handle_ = dlopen(kLibrary.c_str(), RTLD_LAZY); + + char* error_string = dlerror(); + if (error_string == NULL) { + if (CreateManager()) { + policy_manager_->set_listener(this); + event_observer_= new PolicyEventObserver(policy_manager_); + } + } else { + LOG4CXX_ERROR(logger_, error_string); + } + + return policy_manager_.valid(); +} + +bool PolicyHandler::PolicyEnabled() { + return profile::Profile::instance()->enable_policy(); +} + +bool PolicyHandler::CreateManager() { + typedef PolicyManager* (*CreateManager)(); + CreateManager create_manager = reinterpret_cast<CreateManager>(dlsym(dl_handle_, "CreateManager")); + char* error_string = dlerror(); + if (error_string == NULL) { + policy_manager_ = create_manager(); + } else { + LOG4CXX_WARN(logger_, error_string); + } + return policy_manager_; +} + +bool PolicyHandler::InitPolicyTable() { + LOG4CXX_TRACE(logger_, "Init policy table from preloaded."); + POLICY_LIB_CHECK(false); + // Subscribing to notification for system readiness to be able to get system + // info necessary for policy table + event_observer_.get()->subscribe_on_event( + hmi_apis::FunctionID::BasicCommunication_OnReady); + std::string preloaded_file = + profile::Profile::instance()->preloaded_pt_file(); + return policy_manager_->InitPT(preloaded_file); +} + +bool PolicyHandler::ResetPolicyTable() { + LOG4CXX_TRACE(logger_, "Reset policy table."); + POLICY_LIB_CHECK(false); + std::string preloaded_file = + profile::Profile::instance()->preloaded_pt_file(); + return policy_manager_->ResetPT(preloaded_file); +} + +bool PolicyHandler::ClearUserConsent() { + LOG4CXX_INFO(logger_, "Removing user consent records in policy table."); + POLICY_LIB_CHECK(false); + return policy_manager_->ResetUserConsent(); +} + +uint32_t PolicyHandler::GetAppIdForSending() { + // Get app.list + application_manager::ApplicationManagerImpl::ApplicationListAccessor accessor; + const ApplicationList app_list = accessor.applications(); + + if (app_list.empty()) { + return 0; + } + + // Choose application + uint32_t selected_app_id = 0; + AppIds app_ids_last_resort; + AppIds app_ids_preferred; + + ApplicationList::const_iterator it_app_list = app_list.begin(); + ApplicationList::const_iterator it_app_list_end = app_list.end(); + for (; it_app_list != it_app_list_end; ++it_app_list) { + switch ((*it_app_list)->hmi_level()) { + case mobile_apis::HMILevel::HMI_NONE: + app_ids_last_resort.push_back((*it_app_list)->app_id()); + break; + default: + app_ids_preferred.push_back((*it_app_list)->app_id()); + break; + } + } + + AppIds& app_ids_to_use = + app_ids_preferred.empty() ? app_ids_last_resort : app_ids_preferred; + + // Checking, if some of currently known apps was not used already + std::sort(last_used_app_ids_.begin(), last_used_app_ids_.end()); + std::sort(app_ids_to_use.begin(), app_ids_to_use.end()); + + bool is_all_used = std::includes(last_used_app_ids_.begin(), + last_used_app_ids_.end(), + app_ids_to_use.begin(), + app_ids_to_use.end()); + + if (is_all_used) { + last_used_app_ids_.clear(); + } + + // Leave only unused apps + AppIds::iterator it_apps_to_use = app_ids_to_use.begin(); + AppIds::iterator it_apps_to_use_end = app_ids_to_use.end(); + + AppIds::const_iterator it_last_used_app_ids = last_used_app_ids_.begin(); + AppIds::const_iterator it_last_used_app_ids_end = last_used_app_ids_.end(); + + for (; it_last_used_app_ids != it_last_used_app_ids_end; + ++it_last_used_app_ids) { + + std::remove(it_apps_to_use, it_apps_to_use_end, *it_last_used_app_ids); + } + + // Random selection of filtered apps + std::srand(time(0)); + selected_app_id = + *(app_ids_to_use.begin() + (rand() % app_ids_to_use.size())); + + last_used_app_ids_.push_back(selected_app_id); + return selected_app_id; +} + +DeviceConsent PolicyHandler::GetDeviceForSending(DeviceParams& device_params) { + POLICY_LIB_CHECK(kDeviceDisallowed); + uint32_t app_id = 0; + uint32_t app_id_previous = 0; + while (true) { + app_id = GetAppIdForSending(); + if (!app_id) { + LOG4CXX_WARN(logger_, + "There is no appropriate application for sending PTS."); + return kDeviceDisallowed; + } + + // If only one application is available, return its device params + if (app_id == app_id_previous) { + return kDeviceDisallowed; + } + + app_id_previous = app_id; + application_manager::MessageHelper::GetDeviceInfoForApp(app_id, + &device_params); + + DeviceConsent consent = policy_manager_->GetUserConsentForDevice( + device_params.device_mac_address); + switch (consent) { + case kDeviceAllowed: + return consent; + case kDeviceDisallowed: + continue; + case kDeviceHasNoConsent: + return consent; + default: + LOG4CXX_WARN(logger_, "Consent result is not impelemented."); + return consent; + } + } + return kDeviceDisallowed; +} + +const std::string PolicyHandler::ConvertUpdateStatus(PolicyTableStatus status) { + switch (status) { + case policy::StatusUpdatePending: + return "UPDATING"; + case policy::StatusUpdateRequired: + return "UPDATE_NEEDED"; + case policy::StatusUpToDate: + return "UP_TO_DATE"; + default: { + return "UNKNOWN"; + } + } +} + +void PolicyHandler::OnDeviceConsentChanged(const std::string& device_id, + bool is_allowed) { + POLICY_LIB_CHECK_VOID(); + connection_handler::DeviceHandle device_handle; + application_manager::ApplicationManagerImpl::instance()->connection_handler() + ->GetDeviceID(device_id, &device_handle); + // In case of changed consent for device, related applications will be + // limited to pre_DataConsent permissions, if device disallowed, or switch + // back to their own permissions, if device allowed again, and must be + // notified about these changes + + application_manager::ApplicationManagerImpl::ApplicationListAccessor accessor; + ApplicationList app_list = accessor.applications(); + ApplicationList::const_iterator it_app_list = app_list.begin(); + ApplicationList::const_iterator it_app_list_end = app_list.end(); + for (; it_app_list != it_app_list_end; ++it_app_list) { + if (device_handle == (*it_app_list).get()->device()) { + + const std::string policy_app_id = + (*it_app_list)->mobile_app_id()->asString(); + + // If app has predata policy, which is assigned without device consent or + // with negative data consent, there no necessity to change smth and send + // notification for such app in case of device consent is not allowed + if (policy_manager_->IsPredataPolicy(policy_app_id) && + !is_allowed) { + continue; + } + + policy_manager_->ReactOnUserDevConsentForApp(policy_app_id, + is_allowed); + + policy_manager_->SendNotificationOnPermissionsUpdated(policy_app_id); + } + } +} + +void PolicyHandler::AddApplication(const std::string& application_id) { + // TODO (AGaliuzov): remove this workaround during refactoring. + registration_in_progress = true; + POLICY_LIB_CHECK_VOID(); + policy_manager_->AddApplication(application_id); +} + +void PolicyHandler::SetDeviceInfo(std::string& device_id, + const DeviceInfo& device_info) { + LOG4CXX_INFO(logger_, "SetDeviceInfo"); + POLICY_LIB_CHECK_VOID(); + policy_manager_->SetDeviceInfo(device_id, device_info); +} + +void PolicyHandler::OnAppPermissionConsent(const uint32_t connection_key, + PermissionConsent &permissions) { + LOG4CXX_INFO(logger_, "OnAppPermissionConsent"); + POLICY_LIB_CHECK_VOID(); + if (connection_key) { + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application(connection_key); + + if (app.valid()) { + permissions.policy_app_id = app->mobile_app_id()->asString(); + policy::DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForHandle( + app->device(), + &device_params); + + permissions.device_id = device_params.device_mac_address; + } + + if (!permissions.policy_app_id.empty()) { + policy_manager_->SetUserConsentForApp(permissions); + } + + return; + } + + if (!app_to_device_link_.size()) { + LOG4CXX_WARN(logger_, "There are no applications previously stored for " + "setting common permissions."); + return; + } + + std::map<std::string, std::string>::const_iterator it = + app_to_device_link_.begin(); + std::map<std::string, std::string>::const_iterator it_end = + app_to_device_link_.end(); + for (;it != it_end; ++it) { + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance()-> + application_by_policy_id(it->first); + + // If list of apps sent to HMI for user consents is not the same as current, + // permissions should be set only for coincident to registered apps + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Invalid pointer to application was passed." + "Permissions setting skipped."); + continue; + } + + policy::DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForHandle( + app->device(), + &device_params); + + if (device_params.device_mac_address != it->second) { + LOG4CXX_WARN(logger_, "Device_id of application is changed." + "Permissions setting skipped."); + continue; + } + + permissions.policy_app_id = it->first; + permissions.device_id = it->second; + policy_manager_->SetUserConsentForApp(permissions); + } +} + +void PolicyHandler::OnGetUserFriendlyMessage( + const std::vector<std::string>& message_codes, const std::string& language, + uint32_t correlation_id) { + LOG4CXX_INFO(logger_, "OnGetUserFriendlyMessage"); + POLICY_LIB_CHECK_VOID(); + std::vector<UserFriendlyMessage> result = policy_manager_ + ->GetUserFriendlyMessages(message_codes, language); + // Send response to HMI with gathered data + application_manager::MessageHelper::SendGetUserFriendlyMessageResponse( + result, correlation_id); +} + +void PolicyHandler::OnGetListOfPermissions(const uint32_t connection_key, + const uint32_t correlation_id) { + LOG4CXX_INFO(logger_, "OnGetListOfPermissions"); + POLICY_LIB_CHECK_VOID(); + // If no specific app was passed, get permissions for all currently registered + // applications + if (!connection_key) { + LinkAppToDevice linker(app_to_device_link_); + application_manager::ApplicationManagerImpl::ApplicationListAccessor accessor; + const ApplicationList app_list = accessor.applications(); + std::set<application_manager::ApplicationSharedPtr>::const_iterator it_app = + app_list.begin(); + std::set<application_manager::ApplicationSharedPtr>::const_iterator + it_app_end = app_list.end(); + + // Add all currently registered applications + std::for_each(it_app, it_app_end, linker); + + PermissionsConsolidator consolidator; + std::vector<policy::FunctionalGroupPermission> group_permissions; + std::map<std::string, std::string>::const_iterator it = + app_to_device_link_.begin(); + for (;it != app_to_device_link_.end(); ++it) { + policy_manager_->GetUserConsentForApp(it->second, it->first, + group_permissions); + consolidator.Consolidate(group_permissions); + } + + application_manager::MessageHelper::SendGetListOfPermissionsResponse( + consolidator.GetConsolidatedPermissions(), correlation_id); + + return; + } + + // Single app only + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance()->application( + connection_key); + + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Connection key '" << connection_key << "' " + "not found within registered applications."); + return; + } + + DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForApp(connection_key, + &device_params); + std::vector<FunctionalGroupPermission> group_permissions; + if (device_params.device_mac_address.empty()) { + LOG4CXX_WARN(logger_, "Couldn't find device, which hosts application."); + } else if (!app) { + LOG4CXX_WARN(logger_, "Couldn't find application to get permissions."); + } else { + policy_manager_->GetUserConsentForApp(device_params.device_mac_address, + app->mobile_app_id()->asString(), + group_permissions); + + application_manager::MessageHelper::SendGetListOfPermissionsResponse( + group_permissions, correlation_id); + } +} + +void PolicyHandler::OnGetStatusUpdate(const uint32_t correlation_id) { + LOG4CXX_INFO(logger_, "OnGetStatusUpdate"); + POLICY_LIB_CHECK_VOID(); + policy::PolicyTableStatus status = policy_manager_->GetPolicyTableStatus(); + application_manager::MessageHelper::SendGetStatusUpdateResponse( + ConvertUpdateStatus(status), correlation_id); +} + +void PolicyHandler::OnUpdateStatusChanged(PolicyTableStatus status) { + LOG4CXX_INFO(logger_, "OnUpdateStatusChanged"); + application_manager::MessageHelper::SendOnStatusUpdate( + ConvertUpdateStatus(status)); +} + +std::string PolicyHandler::OnCurrentDeviceIdUpdateRequired( + const std::string& policy_app_id) { + LOG4CXX_INFO(logger_, "OnCurrentDeviceIdUpdateRequired"); + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application_by_policy_id(policy_app_id); + + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Application with id '" << policy_app_id << "' " + "not found within registered applications."); + return ""; + } + DeviceParams device_param; + application_manager::MessageHelper::GetDeviceInfoForApp(app->app_id(), + &device_param); + return device_param.device_mac_address; +} + +void PolicyHandler::OnSystemInfoChanged(const std::string& language) { + LOG4CXX_INFO(logger_, "OnSystemInfoChanged"); + POLICY_LIB_CHECK_VOID(); + policy_manager_->SetSystemLanguage(language); +} + +void PolicyHandler::OnGetSystemInfo(const std::string& ccpu_version, + const std::string& wers_country_code, + const std::string& language) { + LOG4CXX_INFO(logger_, "OnGetSystemInfo"); + POLICY_LIB_CHECK_VOID(); + policy_manager_->SetSystemInfo(ccpu_version, wers_country_code, language); +} + +void PolicyHandler::OnSystemInfoUpdateRequired() { + LOG4CXX_INFO(logger_, "OnSystemInfoUpdateRequired"); + POLICY_LIB_CHECK_VOID(); + application_manager::MessageHelper::SendGetSystemInfoRequest(); +} + +void PolicyHandler::OnVIIsReady() { + const uint32_t correlation_id = application_manager:: + ApplicationManagerImpl::instance()->GetNextHMICorrelationID(); + + std::vector<std::string> params; + params.push_back(application_manager::strings::vin); + + application_manager::MessageHelper::CreateGetVehicleDataRequest( + correlation_id, params); + +} + +void PolicyHandler::OnVehicleDataUpdated( + const smart_objects::SmartObject& message) { + POLICY_LIB_CHECK_VOID(); +} + +void PolicyHandler::OnAppRevoked(const std::string& policy_app_id) { + LOG4CXX_TRACE(logger_, "OnAppRevoked with policy_app_id " << policy_app_id << " is revoked."); + POLICY_LIB_CHECK_VOID(); + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application_by_policy_id(policy_app_id); + if (app.valid()) { + DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForApp(app->app_id(), + &device_params); + AppPermissions permissions = policy_manager_->GetAppPermissionsChanges( + device_params.device_mac_address, + policy_app_id); + permissions.appRevoked = true; + application_manager::MessageHelper::SendOnAppPermissionsChangedNotification( + app->app_id(), permissions); + application_manager::MessageHelper:: + SendOnAppInterfaceUnregisteredNotificationToMobile( + app->app_id(), + mobile_apis::AppInterfaceUnregisteredReason::APP_UNAUTHORIZED); + + application_manager::ApplicationManagerImpl::instance()-> + UnregisterRevokedApplication(app->app_id(), + mobile_apis::Result::INVALID_ENUM); + app->set_hmi_level(mobile_apis::HMILevel::HMI_NONE); + policy_manager_->RemovePendingPermissionChanges(policy_app_id); + return; + } +} + +void PolicyHandler::OnPendingPermissionChange( + const std::string& policy_app_id) { + LOG4CXX_INFO(logger_, "PolicyHandler::OnPendingPermissionChange for " + << policy_app_id); + POLICY_LIB_CHECK_VOID(); + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application_by_policy_id(policy_app_id); + if (!app.valid()) { + LOG4CXX_WARN(logger_, + "No app found for " << policy_app_id << " policy app id."); + return; + } + + DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForApp(app->app_id(), + &device_params); + AppPermissions permissions = policy_manager_->GetAppPermissionsChanges( + device_params.device_mac_address, + policy_app_id); + + mobile_apis::HMILevel::eType app_hmi_level = app->hmi_level(); + + switch (app_hmi_level) { + case mobile_apis::HMILevel::HMI_FULL: + case mobile_apis::HMILevel::HMI_LIMITED: { + if (permissions.appPermissionsConsentNeeded) { + application_manager::MessageHelper:: + SendOnAppPermissionsChangedNotification(app->app_id(), permissions); + + policy_manager_->RemovePendingPermissionChanges(policy_app_id); + } + break; + } + case mobile_apis::HMILevel::HMI_BACKGROUND: { + if (permissions.isAppPermissionsRevoked) { + application_manager::MessageHelper:: + SendOnAppPermissionsChangedNotification(app->app_id(), permissions); + + policy_manager_->RemovePendingPermissionChanges(policy_app_id); + } + break; + } + default: + break; + } + + if (permissions.appUnauthorized) { + if (mobile_apis::HMILevel::HMI_FULL == app_hmi_level || + mobile_apis::HMILevel::HMI_LIMITED == app_hmi_level) { + application_manager::MessageHelper:: + SendOnAppPermissionsChangedNotification(app->app_id(), permissions); + } + application_manager::MessageHelper:: + SendOnAppInterfaceUnregisteredNotificationToMobile( + app->app_id(), + mobile_apis::AppInterfaceUnregisteredReason::APP_UNAUTHORIZED); + + application_manager::ApplicationManagerImpl::instance()-> + UnregisterRevokedApplication(app->app_id(), + mobile_apis::Result::INVALID_ENUM); + + policy_manager_->RemovePendingPermissionChanges(policy_app_id); + } +} + +bool PolicyHandler::SendMessageToSDK(const BinaryMessage& pt_string) { + LOG4CXX_INFO(logger_, "PolicyHandler::SendMessageToSDK"); + POLICY_LIB_CHECK(false); + + std::string url; + uint32_t app_id = last_used_app_ids_.back(); + + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application(app_id); + + if (!app.valid()) { + LOG4CXX_WARN(logger_, "There is no registered application with " + "connection key '" << app_id << "'"); + return false; + } + + const std::string& mobile_app_id = app->mobile_app_id()->asString(); + if (mobile_app_id.empty()) { + LOG4CXX_WARN(logger_, "Application with connection key '" << app_id << "'" + " has no application id."); + return false; + } + url = policy_manager_->GetUpdateUrl(PolicyServiceTypes::POLICY); + + LOG4CXX_INFO(logger_, "Update url is " << url << " for application " + << application_manager::ApplicationManagerImpl::instance() + ->application(app_id)->name()); + + application_manager::MessageHelper::SendPolicySnapshotNotification(app_id, + pt_string, + url, 0); + + return true; +} + +bool PolicyHandler::ReceiveMessageFromSDK(const std::string& file, + const BinaryMessage& pt_string) { + POLICY_LIB_CHECK(false); + + if (policy_manager_->GetPolicyTableStatus() != + PolicyTableStatus::StatusUpdatePending) { + LOG4CXX_WARN(logger_, "PTU processing skipped, since current status is " + "different from pending."); + return false; + } + + bool ret = policy_manager_->LoadPT(file, pt_string); + LOG4CXX_INFO(logger_, "Policy table is saved: " << std::boolalpha << ret); + if (ret) { + LOG4CXX_INFO(logger_, "PTU was successful."); + exchange_handler_->Stop(); + policy_manager_->CleanupUnpairedDevices(); + int32_t correlation_id = + application_manager::ApplicationManagerImpl::instance() + ->GetNextHMICorrelationID(); + + event_observer_.get()->subscribe_on_event( +#ifdef HMI_DBUS_API + hmi_apis::FunctionID::VehicleInfo_GetOdometer, correlation_id +#else + hmi_apis::FunctionID::VehicleInfo_GetVehicleData, correlation_id +#endif + ); + std::vector<std::string> vehicle_data_args; + vehicle_data_args.push_back(application_manager::strings::odometer); + application_manager::MessageHelper::CreateGetVehicleDataRequest( + correlation_id, vehicle_data_args); + } else { + LOG4CXX_WARN(logger_, "Exchange wasn't successful, trying another one."); + OnPTExchangeNeeded(); + } + return ret; +} + +bool PolicyHandler::UnloadPolicyLibrary() { + LOG4CXX_TRACE(logger_, "enter. policy_manager_ = " << policy_manager_); + bool ret = true; + if (policy_manager_) { + policy_manager_.release(); + } + if (dl_handle_) { + ret = (dlclose(dl_handle_) == 0); + dl_handle_ = 0; + } + exchange_handler_->Stop(); + LOG4CXX_TRACE(logger_, "exit"); + return ret; +} + +void PolicyHandler::StartPTExchange(bool skip_device_selection) { + LOG4CXX_INFO(logger_, "PolicyHandler::StartPTExchange"); + POLICY_LIB_CHECK_VOID(); + + if (policy_manager_->GetPolicyTableStatus() == + PolicyTableStatus::StatusUpdatePending) { + LOG4CXX_INFO(logger_, "Starting exchange skipped, since another exchange " + "is in progress."); + return; + } + + if (!skip_device_selection) { + DeviceParams device_params; + DeviceConsent consent = GetDeviceForSending(device_params); + switch (consent) { + case kDeviceHasNoConsent: + // Send OnSDLConsentNeeded to HMI for user consent on device usage + pending_device_handles_.push_back(device_params.device_handle); + application_manager::MessageHelper::SendOnSDLConsentNeeded( + device_params); + return; + case kDeviceDisallowed: + return; + default: + break; + } + } + + exchange_handler_->Start(); +} + +void PolicyHandler::OnAllowSDLFunctionalityNotification(bool is_allowed, + uint32_t device_id) { + LOG4CXX_INFO(logger_, "OnAllowSDLFunctionalityNotification"); + POLICY_LIB_CHECK_VOID(); + // Device ids, need to be changed + std::set<uint32_t> device_ids; + bool device_specific = device_id != 0; + // Common devices consents change + if (!device_specific) { + application_manager::ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<application_manager::ApplicationSharedPtr> app_list = + accessor.applications(); + + std::set<application_manager::ApplicationSharedPtr>::const_iterator + it_app_list = app_list.begin(); + std::set<application_manager::ApplicationSharedPtr>::const_iterator + it_app_end = app_list.end(); + + for (;it_app_list != it_app_end; ++it_app_list) { + if (!(*it_app_list).valid()) { + continue; + } + device_ids.insert(it_app_list->get()->device()); + } + } else { + device_ids.insert(device_id); + } + + std::set<uint32_t>::const_iterator it_ids = device_ids.begin(); + std::set<uint32_t>::const_iterator it_ids_end = device_ids.end(); + for (;it_ids != it_ids_end; ++it_ids) { + const uint32_t device_id = *it_ids; + + DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForHandle(device_id, + &device_params); + device_params.device_handle = device_id; + if (kDefaultDeviceMacAddress == device_params.device_mac_address) { + LOG4CXX_WARN(logger_, "Device with handle " << device_id + << " wasn't found."); + return; + } + policy_manager_->SetUserConsentForDevice(device_params.device_mac_address, + is_allowed); + + } + + // Case, when specific device was changed + if (device_id) { + DeviceHandles::iterator it = std::find(pending_device_handles_.begin(), + pending_device_handles_.end(), + device_id); + // If consent done from HMI menu + if (it == pending_device_handles_.end()) { + return; + } + + pending_device_handles_.erase(it); + } + +// EXTENDED_POLICY + // Skip device selection, since user already consented device usage + StartPTExchange(true); +} + +void PolicyHandler::OnIgnitionCycleOver() { + LOG4CXX_INFO(logger_, "OnIgnitionCycleOver"); + POLICY_LIB_CHECK_VOID(); + policy_manager_->IncrementIgnitionCycles(); +} + +void PolicyHandler::KmsChanged(int kms) { + LOG4CXX_INFO(logger_, "PolicyHandler::KmsChanged " << kms << " kilometers"); + POLICY_LIB_CHECK_VOID(); + PTExchangeAtOdometer(kms); +} + +void PolicyHandler::OnActivateApp(uint32_t connection_key, + uint32_t correlation_id) { + LOG4CXX_INFO(logger_, "OnActivateApp"); + + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance()->application( + connection_key); + if (!app.valid()) { + LOG4CXX_WARN(logger_, "Activated App failed: no app found."); + return; + } + std::string policy_app_id = app->mobile_app_id()->asString(); + + AppPermissions permissions(policy_app_id); + + if (!policy_manager_) { + LOG4CXX_WARN(logger_, "The shared library of policy is not loaded"); + if (!PolicyEnabled()) { + permissions.isSDLAllowed = true; + } + } else { + DeviceParams device_params; + application_manager::MessageHelper::GetDeviceInfoForApp(connection_key, + &device_params); + permissions = policy_manager_->GetAppPermissionsChanges( + device_params.device_mac_address, + policy_app_id); + + permissions.isSDLAllowed = true; + + if (permissions.isSDLAllowed && + PolicyTableStatus::StatusUpdateRequired == + policy_manager_->GetPolicyTableStatus()) { + StartPTExchange(); + } + policy_manager_->RemovePendingPermissionChanges(policy_app_id); + } + + bool is_app_activated = false; + // If application is revoked it should not be activated + // In this case we need to activate application + if (false == permissions.appRevoked && true == permissions.isSDLAllowed) { + is_app_activated = + application_manager::ApplicationManagerImpl::instance()-> + ActivateApplication(app); + } + + last_activated_app_id_ = connection_key; + application_manager::MessageHelper::SendSDLActivateAppResponse(permissions, + correlation_id); + if (is_app_activated) { + application_manager::MessageHelper::SendHMIStatusNotification(*app.get()); + } +} + +void PolicyHandler::PTExchangeAtRegistration(const std::string& app_id) { + LOG4CXX_INFO(logger_, "PTExchangeAtIgnition"); + POLICY_LIB_CHECK_VOID(); + + if (policy_manager_->IsAppInUpdateList(app_id)) { + StartPTExchange(); + } else if (false == on_ignition_check_done_) { // TODO(AG): add cond. var to handle this case. + TimevalStruct current_time = date_time::DateTime::getCurrentTime(); + const int kSecondsInDay = 60 * 60 * 24; + int days = current_time.tv_sec / kSecondsInDay; + + LOG4CXX_INFO( + logger_, + "\nIgnition cycles exceeded: " << std::boolalpha << + policy_manager_->ExceededIgnitionCycles() + << "\nDays exceeded: " << std::boolalpha + << policy_manager_->ExceededDays(days) + << "\nStatusUpdateRequired: " << std::boolalpha + << (policy_manager_->GetPolicyTableStatus() == StatusUpdateRequired)); + if (policy_manager_->ExceededIgnitionCycles() + || policy_manager_->ExceededDays(days) + || policy_manager_->GetPolicyTableStatus() == StatusUpdateRequired) { + StartPTExchange(); + } + } + on_ignition_check_done_ = true; +} + +void PolicyHandler::PTExchangeAtOdometer(int kilometers) { + POLICY_LIB_CHECK_VOID(); + if (policy_manager_->ExceededKilometers(kilometers)) { + LOG4CXX_INFO(logger_, "Enough kilometers passed to send for PT update."); + StartPTExchange(); + } +} + +void PolicyHandler::PTExchangeAtUserRequest(uint32_t correlation_id) { + LOG4CXX_TRACE(logger_, "PT exchange at user request"); + POLICY_LIB_CHECK_VOID(); + policy::PolicyTableStatus status = policy_manager_->GetPolicyTableStatus(); + if (status != policy::StatusUpdatePending) { + OnPTExchangeNeeded(); + status = policy::StatusUpdatePending; + } else { + is_user_requested_policy_table_update_ = true; + } + application_manager::MessageHelper::SendUpdateSDLResponse( + ConvertUpdateStatus(status), correlation_id); +} + +void PolicyHandler::OnPTExchangeNeeded() { + StartPTExchange(); +} + +void PolicyHandler::OnPermissionsUpdated(const std::string& policy_app_id, + const Permissions& permissions, + const HMILevel& default_hmi) { + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application_by_policy_id(policy_app_id); + + if (!app.valid()) { + LOG4CXX_WARN( + logger_, + "Connection_key not found for application_id:" << policy_app_id); + return; + } + + application_manager::MessageHelper::SendOnPermissionsChangeNotification( + app->app_id(), permissions); + + LOG4CXX_INFO( + logger_, + "Notification sent for application_id:" << policy_app_id + << " and connection_key " << app->app_id()); + + // The application currently not running (i.e. in NONE) should change HMI + // level to default + mobile_apis::HMILevel::eType current_hmi_level = app->hmi_level(); + mobile_apis::HMILevel::eType hmi_level = + application_manager::MessageHelper::StringToHMILevel(default_hmi); + + if (mobile_apis::HMILevel::INVALID_ENUM == hmi_level) { + LOG4CXX_WARN(logger_, "Couldn't convert default hmi level " + << default_hmi << " to enum."); + return; + } + if (current_hmi_level == hmi_level) { + LOG4CXX_INFO(logger_, "Application already in default hmi state."); + return; + } + switch (current_hmi_level) { + case mobile_apis::HMILevel::HMI_NONE: { + LOG4CXX_INFO(logger_, "Changing hmi level of application " + << policy_app_id + << " to default hmi level " << default_hmi); + // If default is FULL, send request to HMI. Notification to mobile will be + // sent on response receiving. + if (mobile_apis::HMILevel::HMI_FULL == hmi_level) { + application_manager::MessageHelper::SendActivateAppToHMI(app->app_id()); + break; + } + + // Set application hmi level + app->set_hmi_level(hmi_level); + + // Send notification to mobile + application_manager::MessageHelper::SendHMIStatusNotification(*app.get()); + } + break; + default: + LOG4CXX_WARN(logger_, "Application " << policy_app_id << " is running." + "HMI level won't be changed."); + break; + } +} + +bool PolicyHandler::GetPriority(const std::string& policy_app_id, + std::string* priority) { + POLICY_LIB_CHECK(false); + return policy_manager_->GetPriority(policy_app_id, priority); +} + +void PolicyHandler::CheckPermissions(const PTString& app_id, + const PTString& hmi_level, + const PTString& rpc, + const RPCParams& rpc_params, + CheckPermissionResult& result) { + POLICY_LIB_CHECK_VOID(); + policy_manager_->CheckPermissions(app_id, hmi_level, rpc, rpc_params, result); +} + +uint32_t PolicyHandler::GetNotificationsNumber(const std::string& priority) { + POLICY_LIB_CHECK(0); + return policy_manager_->GetNotificationsNumber(priority); +} + +DeviceConsent PolicyHandler::GetUserConsentForDevice( + const std::string& device_id) { + POLICY_LIB_CHECK(kDeviceDisallowed); + return policy_manager_->GetUserConsentForDevice(device_id); +} + +bool PolicyHandler::GetDefaultHmi(const std::string& policy_app_id, + std::string* default_hmi) { + POLICY_LIB_CHECK(false); + return policy_manager_->GetDefaultHmi(policy_app_id, default_hmi); +} + +bool PolicyHandler::GetInitialAppData(const std::string& application_id, + StringArray* nicknames, + StringArray* app_hmi_types) { + POLICY_LIB_CHECK(false); + return policy_manager_->GetInitialAppData(application_id, nicknames, app_hmi_types); +} + +EndpointUrls PolicyHandler::GetUpdateUrls(int service_type) { + POLICY_LIB_CHECK(EndpointUrls()); + return policy_manager_->GetUpdateUrls(service_type); +} + +void PolicyHandler::ResetRetrySequence() { + POLICY_LIB_CHECK_VOID(); + policy_manager_->ResetRetrySequence(); +} + +int PolicyHandler::NextRetryTimeout() { + POLICY_LIB_CHECK(0); + return policy_manager_->NextRetryTimeout(); +} + +int PolicyHandler::TimeoutExchange() { + POLICY_LIB_CHECK(0); + return policy_manager_->TimeoutExchange(); +} + +void PolicyHandler::OnExceededTimeout() { + POLICY_LIB_CHECK_VOID(); + policy_manager_->OnExceededTimeout(); +} + +BinaryMessageSptr PolicyHandler::RequestPTUpdate() { + POLICY_LIB_CHECK(BinaryMessageSptr()); + return policy_manager_->RequestPTUpdate(); +} + +const std::vector<int> PolicyHandler::RetrySequenceDelaysSeconds() { + POLICY_LIB_CHECK(std::vector<int>()); + return policy_manager_->RetrySequenceDelaysSeconds(); +} + +utils::SharedPtr<usage_statistics::StatisticsManager> +PolicyHandler::GetStatisticManager() { + return utils::SharedPtr<PolicyManager>:: + static_pointer_cast<usage_statistics::StatisticsManager>(policy_manager_); +} + +void PolicyHandler::AddStatisticsInfo(int type) { + POLICY_LIB_CHECK_VOID(); + switch (static_cast<hmi_apis::Common_StatisticsType::eType>(type)) { + case hmi_apis::Common_StatisticsType::iAPP_BUFFER_FULL: { + usage_statistics::GlobalCounter count_of_iap_buffer_full( + GetStatisticManager(), usage_statistics::IAP_BUFFER_FULL); + ++count_of_iap_buffer_full; + break; + } + default: { + LOG4CXX_WARN(logger_, "Type of statistics is unknown"); + } + } +} + +void PolicyHandler::OnSystemError(int code) { + POLICY_LIB_CHECK_VOID(); + switch (static_cast<hmi_apis::Common_SystemError::eType>(code)) { + case hmi_apis::Common_SystemError::SYNC_REBOOTED: { + usage_statistics::GlobalCounter count_of_sync_reboots( + GetStatisticManager(), usage_statistics::SYNC_REBOOTS); + ++count_of_sync_reboots; + break; + } + case hmi_apis::Common_SystemError::SYNC_OUT_OF_MEMMORY: { + usage_statistics::GlobalCounter count_sync_out_of_memory( + GetStatisticManager(), usage_statistics::SYNC_OUT_OF_MEMORY); + ++count_sync_out_of_memory; + break; + } + default: { + LOG4CXX_WARN(logger_, "System error is unknown"); + } + } +} + +std::string PolicyHandler::GetAppName(const std::string& policy_app_id) { + application_manager::ApplicationSharedPtr app = + application_manager::ApplicationManagerImpl::instance() + ->application_by_policy_id(policy_app_id); + + if (!app.valid()) { + LOG4CXX_WARN( + logger_, + "Connection_key not found for application_id:" << policy_app_id); + return ""; + } + return app->name(); +} + +void PolicyHandler::OnUserRequestedUpdateCheckRequired() { + LOG4CXX_INFO(logger_, "OnUserRequestedUpdateCheckRequired"); + POLICY_LIB_CHECK_VOID(); + policy::PolicyTableStatus status = policy_manager_->GetPolicyTableStatus(); + if (is_user_requested_policy_table_update_ && + status != policy::StatusUpdatePending) { + is_user_requested_policy_table_update_ = false; + OnPTExchangeNeeded(); + return; + } + LOG4CXX_WARN(logger_, "There is another pending update is present." + "User-requested update is postponed."); +} + +void PolicyHandler::RemoveDevice(const std::string& device_id) { + LOG4CXX_INFO(logger_, "PolicyHandler::RemoveDevice"); + POLICY_LIB_CHECK_VOID(); + + policy_manager_->MarkUnpairedDevice(device_id); + +} + +bool PolicyHandler::IsApplicationRevoked(const std::string& app_id) { + LOG4CXX_TRACE(logger_, "PolicyHandler::IsApplicationRevoked"); + POLICY_LIB_CHECK(false); + + return policy_manager_->IsApplicationRevoked(app_id); +} + +void PolicyHandler::OnUpdateRequestSentToMobile() { + LOG4CXX_INFO(logger_, "OnUpdateRequestSentToMobile"); + POLICY_LIB_CHECK_VOID(); + policy_manager_->OnUpdateStarted(); +} + +bool PolicyHandler::CheckKeepContext(int system_action, + const std::string& policy_app_id) { + POLICY_LIB_CHECK(false); + const bool keep_context = system_action + == mobile_apis::SystemAction::KEEP_CONTEXT; + const bool allowed = policy_manager_->CanAppKeepContext(policy_app_id); + return !(keep_context && !allowed); +} + +bool PolicyHandler::CheckStealFocus(int system_action, + const std::string& policy_app_id) { + POLICY_LIB_CHECK(false); + const bool steal_focus = system_action + == mobile_apis::SystemAction::STEAL_FOCUS; + const bool allowed = policy_manager_->CanAppStealFocus(policy_app_id); + return !(steal_focus && !allowed); +} + +uint16_t PolicyHandler::HeartBeatTimeout(const std::string& app_id) const { + POLICY_LIB_CHECK(0); + return policy_manager_->HeartBeatTimeout(app_id); +} + +} // namespace policy + diff --git a/src/components/application_manager/src/policies/policy_retry_sequence.cc b/src/components/application_manager/src/policies/policy_retry_sequence.cc new file mode 100644 index 0000000000..e1b47a0d96 --- /dev/null +++ b/src/components/application_manager/src/policies/policy_retry_sequence.cc @@ -0,0 +1,80 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/policies/policy_retry_sequence.h" + +#include <unistd.h> + +#include "application_manager/policies/policy_handler.h" + +namespace policy { + +CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler") + +RetrySequence::RetrySequence(PolicyHandler* const policy_handler) + // TODO (Risk copy of PolicyHandler Pointer) + : policy_handler_(policy_handler) { +} + +void RetrySequence::threadMain() { + StartNextRetry(); +} + +void RetrySequence::StartNextRetry() { + LOG4CXX_TRACE(logger_, "Start next retry of exchanging PT"); + DCHECK(policy_handler_); + // TODO(Ezamakhov): inverstigate StartNextRetry on unload policy lib + + BinaryMessageSptr pt_snapshot = policy_handler_ + ->RequestPTUpdate(); + if (pt_snapshot) { + policy_handler_->SendMessageToSDK(*pt_snapshot); + + const int timeout = policy_handler_->TimeoutExchange(); + const int seconds = policy_handler_->NextRetryTimeout(); + LOG4CXX_DEBUG(logger_, + "Timeout response: " << timeout << " Next try: " << seconds); + if (timeout > 0) { + sleep(timeout); + policy_handler_->OnExceededTimeout(); + } + if (seconds > 0) { + sleep(seconds); + StartNextRetry(); + } else { + LOG4CXX_INFO(logger_, "End retry sequence. Update PT was not received"); + } + } +} + +} // namespace policy + diff --git a/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc b/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc new file mode 100644 index 0000000000..eba808f406 --- /dev/null +++ b/src/components/application_manager/src/policies/pt_exchange_handler_ext.cc @@ -0,0 +1,88 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/policies/pt_exchange_handler_ext.h" + +#include <fstream> +#include <string> + +#include "application_manager/message_helper.h" +#include "config_profile/profile.h" +#include "utils/file_system.h" + +using application_manager::MessageHelper; +using profile::Profile; +using std::string; + + +namespace policy { + +CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler") + +PTExchangeHandlerExt::PTExchangeHandlerExt(PolicyHandler* policy_handler) + : PTExchangeHandler(), + policy_handler_(policy_handler) { + DCHECK(policy_handler_); +} + +PTExchangeHandlerExt::~PTExchangeHandlerExt() { +} + +void PTExchangeHandlerExt::Start() { + LOG4CXX_TRACE(logger_, "Start exchange PT"); + + const string policy_snapshot_file_name = + Profile::instance()->policies_snapshot_file_name(); + const std::string system_files_path = + Profile::instance()->system_files_path(); + const std::string policy_snapshot_full_path = system_files_path + '/' + + policy_snapshot_file_name; + BinaryMessageSptr pt_snapshot = policy_handler_->RequestPTUpdate(); + if (pt_snapshot.valid()) { + if (file_system::CreateDirectoryRecursively(system_files_path) && + file_system::WriteBinaryFile(policy_snapshot_full_path, *pt_snapshot)) { + MessageHelper::SendPolicyUpdate(policy_snapshot_full_path, + policy_handler_->TimeoutExchange(), + policy_handler_->RetrySequenceDelaysSeconds()); + } else { + LOG4CXX_ERROR(logger_, "Failed to write snapshot file to " << policy_snapshot_file_name); + } + } else { + LOG4CXX_ERROR(logger_, "Failed to obtain policy table snapshot"); + } +} + +void PTExchangeHandlerExt::Stop() { + // Nothing doing +} + +} // namespace policy diff --git a/src/components/application_manager/src/policies/pt_exchange_handler_impl.cc b/src/components/application_manager/src/policies/pt_exchange_handler_impl.cc new file mode 100644 index 0000000000..e28455aa33 --- /dev/null +++ b/src/components/application_manager/src/policies/pt_exchange_handler_impl.cc @@ -0,0 +1,76 @@ +/* + Copyright (c) 2013, Ford Motor Company + 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 Ford Motor Company nor the names of its 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 "application_manager/policies/pt_exchange_handler_impl.h" + +#include "utils/logger.h" +#include "application_manager/policies/policy_handler.h" +#include "application_manager/policies/policy_retry_sequence.h" + +namespace policy { + +CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyHandler") + +PTExchangeHandlerImpl::PTExchangeHandlerImpl(PolicyHandler* handler) + : policy_handler_(handler), + retry_sequence_("RetrySequence", new RetrySequence(handler)) { + DCHECK(policy_handler_); + LOG4CXX_INFO(logger_, "Exchan created"); +} + +PTExchangeHandlerImpl::~PTExchangeHandlerImpl() { + Stop(); + policy_handler_ = NULL; +} + +void PTExchangeHandlerImpl::Start() { + sync_primitives::AutoLock locker(retry_sequence_lock_); + LOG4CXX_INFO(logger_, "Exchan started"); + + if (retry_sequence_.is_running()) { + retry_sequence_.stop(); + } + + if (policy_handler_) { + policy_handler_->ResetRetrySequence(); + } + retry_sequence_.start(); +} + +void PTExchangeHandlerImpl::Stop() { + sync_primitives::AutoLock locker(retry_sequence_lock_); + if (retry_sequence_.is_running()) { + retry_sequence_.stop(); + } +} + +} // namespace policy diff --git a/src/components/application_manager/src/request_controller.cc b/src/components/application_manager/src/request_controller.cc new file mode 100644 index 0000000000..48fee42920 --- /dev/null +++ b/src/components/application_manager/src/request_controller.cc @@ -0,0 +1,508 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 <algorithm> +#include "utils/logger.h" +#include "config_profile/profile.h" +#include "application_manager/request_controller.h" +#include "application_manager/commands/command_request_impl.h" +#include "application_manager/commands/hmi/request_to_hmi.h" + +namespace application_manager { + +namespace request_controller { + +using namespace sync_primitives; + +CREATE_LOGGERPTR_GLOBAL(logger_, "RequestController"); + +RequestController::RequestController() + : pool_state_(UNDEFINED), + pool_size_(profile::Profile::instance()->thread_pool_size()), + pending_request_set_lock_(true), + timer_("RequestCtrlTimer", this, &RequestController::onTimer, true) +{ + LOG4CXX_INFO(logger_, "RequestController::RequestController()"); + InitializeThreadpool(); + timer_.start(dafault_sleep_time_); + LOG4CXX_DEBUG(logger_," Create timer thread ; timer thread = " << timer_.thread_->thread_handle()); +} + +RequestController::~RequestController() { + LOG4CXX_TRACE_ENTER(logger_); + if (pool_state_ != TPoolState::STOPPED) { + DestroyThreadpool(); + } + + pool_.clear(); + mobile_request_list_.clear(); + pending_request_set_.clear(); +} + +void RequestController::InitializeThreadpool() +{ + LOG4CXX_TRACE_ENTER(logger_); + // TODO: Consider lazy loading threads instead of creating all at once + pool_state_ = TPoolState::STARTED; + for (uint32_t i = 0; i < pool_size_; i++) { + char name [50]; + snprintf(name, sizeof(name)/sizeof(name[0]), + "AM Pool %d", i); + pool_.push_back(ThreadSharedPtr(new Thread(name, new Worker(this)))); + pool_[i]->start(); + LOG4CXX_INFO(logger_, "Request thread initialized: " << name); + } +} + +void RequestController::DestroyThreadpool() { + LOG4CXX_TRACE_ENTER(logger_); + { + sync_primitives::AutoLock auto_lock (mobile_request_list_lock_); + pool_state_ = TPoolState::STOPPED; + LOG4CXX_INFO(logger_, "Broadcasting STOP signal to all threads..."); + cond_var_.Broadcast(); // notify all threads we are shutting down + } + for (uint32_t i = 0; i < pool_size_; i++) { + pool_[i]->stop(); + } + LOG4CXX_INFO(logger_, "Threads exited from the thread pool " << pool_size_); +} + +RequestController::TResult RequestController::addMobileRequest( + const MobileRequestPtr& request, + const mobile_apis::HMILevel::eType& hmi_level) { + LOG4CXX_TRACE_ENTER(logger_); + if (!request.valid()) { + LOG4CXX_INFO(logger_, "Null Pointer request"); + LOG4CXX_TRACE_EXIT(logger_); + cond_var_.NotifyOne(); + return INVALID_DATA; + } + + TResult result = SUCCESS; + const commands::CommandRequestImpl* request_impl = + static_cast<commands::CommandRequestImpl*>(request.get()); + LOG4CXX_DEBUG(logger_, "addMobileRequest " << request_impl->correlation_id()); + const uint32_t& app_hmi_level_none_time_scale = + profile::Profile::instance()->app_hmi_level_none_time_scale(); + + const uint32_t& app_hmi_level_none_max_request_per_time_scale = + profile::Profile::instance()->app_hmi_level_none_time_scale_max_requests(); + + const uint32_t& app_time_scale = + profile::Profile::instance()->app_time_scale(); + + const uint32_t& max_request_per_time_scale = + profile::Profile::instance()->app_time_scale_max_requests(); + + const uint32_t& pending_requests_amount = + profile::Profile::instance()->pending_requests_amount(); + + if (!checkHMILevelTimeScaleMaxRequest(mobile_apis::HMILevel::HMI_NONE, + request_impl->connection_key(), app_hmi_level_none_time_scale, + app_hmi_level_none_max_request_per_time_scale)) { + LOG4CXX_ERROR(logger_, "Too many application requests in hmi level NONE"); + result = RequestController::NONE_HMI_LEVEL_MANY_REQUESTS; + } else if (!checkTimeScaleMaxRequest( + request_impl->connection_key(), + app_time_scale, max_request_per_time_scale)) { + LOG4CXX_ERROR(logger_, "Too many application requests"); + result = RequestController::TOO_MANY_REQUESTS; + } else if (pending_requests_amount == mobile_request_list_.size()) { + LOG4CXX_ERROR(logger_, "Too many pending request"); + result = RequestController::TOO_MANY_PENDING_REQUESTS; + } + { + AutoLock auto_lock(mobile_request_list_lock_); + + mobile_request_list_.push_back(request); + LOG4CXX_INFO(logger_, "mobile_request_list_ size is " + << mobile_request_list_.size() + << " pending_request_set_ size is " + << pending_request_set_.size() + ); + } + + // wake up one thread that is waiting for a task to be available + cond_var_.NotifyOne(); + LOG4CXX_TRACE_EXIT(logger_); + return result; +} + +RequestController::TResult RequestController::addHMIRequest( + const RequestPtr& request) { + LOG4CXX_TRACE_ENTER(logger_); + DCHECK(request.valid()); + LOG4CXX_DEBUG(logger_, "addHMIRequest " << request->correlation_id()); + RequestInfoPtr request_info_ptr = new HMIRequestInfo(request, request->default_timeout()); + + + if (0 != request->default_timeout()) { + pending_request_set_lock_.Acquire(); + pending_request_set_.insert(request_info_ptr); + LOG4CXX_INFO(logger_, "pending_request_set_ size is " + << pending_request_set_.size()); + UpdateTimer(); + pending_request_set_lock_.Release(); + } else { + LOG4CXX_INFO(logger_, "Default timeout was set to 0." + "RequestController will not track timeout of this request."); + } + LOG4CXX_TRACE_EXIT(logger_); + return RequestController::SUCCESS; +} + +void RequestController::addNotification(const RequestPtr ptr) { + LOG4CXX_TRACE_ENTER(logger_); + notification_list_.push_back(ptr); + LOG4CXX_TRACE_EXIT(logger_); +} + +void RequestController::removeNotification(const commands::Command* notification) { + LOG4CXX_TRACE_ENTER(logger_); + std::list<RequestPtr>::iterator it = notification_list_.begin(); + for (; notification_list_.end() != it; ++it) { + if (it->get() == notification) { + notification_list_.erase(it); + break; + } + } + LOG4CXX_TRACE_EXIT(logger_); +} + +void RequestController::terminateMobileRequest( + const uint32_t& mobile_correlation_id) { + LOG4CXX_TRACE_ENTER(logger_); + + AutoLock auto_lock(pending_request_set_lock_); + RequestInfoSet::iterator it = pending_request_set_.begin(); + for (; pending_request_set_.end() != it; ++it) { + MobileRequestInfo* mobile_request_info = dynamic_cast<MobileRequestInfo*>(it->get()); + if (NULL == mobile_request_info) { + continue; + } + if (mobile_correlation_id == mobile_request_info->mobile_correlation_id_) { + mobile_request_info->request_->CleanUp(); + pending_request_set_.erase(it); + LOG4CXX_INFO(logger_, "Mobile request terminated: " << mobile_correlation_id); + UpdateTimer(); + LOG4CXX_TRACE_EXIT(logger_); + return; + } + } + LOG4CXX_INFO(logger_, "Mobile request NOT terminated: " << mobile_correlation_id << + " pending_request_set_ size : " << pending_request_set_.size()); + LOG4CXX_TRACE_EXIT(logger_); +} + +void RequestController::terminateHMIRequest(const uint32_t &correlation_id) { + LOG4CXX_TRACE_ENTER(logger_); + AutoLock auto_lock(pending_request_set_lock_); + RequestInfoSet::iterator it = pending_request_set_.begin(); + for (; pending_request_set_.end() != it; ++it) { + HMIRequestInfo* hmi_request_info = dynamic_cast<HMIRequestInfo*>(it->get()); + if (NULL == hmi_request_info) { + continue; + } + if (correlation_id == hmi_request_info->requestId()) { + hmi_request_info->request_->CleanUp(); + pending_request_set_.erase(it); + LOG4CXX_DEBUG(logger_, "HMI request terminated: " << correlation_id); + UpdateTimer(); + LOG4CXX_TRACE_EXIT(logger_); + return; + } + } + LOG4CXX_INFO(logger_, "HMI request NOT terminated: " << correlation_id << + " pending_request_set_ size : " << pending_request_set_.size()); + LOG4CXX_TRACE_EXIT(logger_); +} + +void RequestController::terminateAppRequests( + const uint32_t& app_id) { + LOG4CXX_TRACE_ENTER(logger_); + + AutoLock auto_lock(pending_request_set_lock_); + RequestInfoSet::iterator it = pending_request_set_.begin(); + while (pending_request_set_.end() != it) { + MobileRequestInfo* mobile_request_info = dynamic_cast<MobileRequestInfo*>(it->get()); + if (NULL == mobile_request_info) { + ++it; + continue; + } + + if (mobile_request_info->app_id_ == app_id) { + mobile_request_info->request_->CleanUp(); + pending_request_set_.erase(it++); + LOG4CXX_INFO(logger_, "terminated all app requests : " << app_id); + } else { + ++it; + } + } + UpdateTimer(); + LOG4CXX_TRACE_EXIT(logger_); +} + +void RequestController::terminateAllHMIRequests() { + LOG4CXX_TRACE_ENTER(logger_); + AutoLock auto_lock(pending_request_set_lock_); + RequestInfoSet::iterator it = pending_request_set_.begin(); + while (pending_request_set_.end() != it) { + HMIRequestInfo* hmi_request_info = dynamic_cast<HMIRequestInfo*>(it->get()); + if (NULL == hmi_request_info) { + ++it; + continue; + } + hmi_request_info->request_->CleanUp(); + pending_request_set_.erase(it++); + LOG4CXX_INFO(logger_, "HMI request terminated: "); + } + LOG4CXX_TRACE_EXIT(logger_); +} + +void RequestController::updateRequestTimeout( + const uint32_t& app_id, + const uint32_t& mobile_correlation_id, + const uint32_t& new_timeout) { + + LOG4CXX_TRACE_ENTER(logger_); + + AutoLock auto_lock(pending_request_set_lock_); + RequestInfoSet::iterator it = pending_request_set_.begin(); + MobileRequestInfo* mobile_request_info = NULL; + RequestInfoPtr request_info; + for (; pending_request_set_.end() != it; ++it) { + request_info = *it; + if (false == request_info.valid()) { + LOG4CXX_ERROR(logger_, "Invalid request, can't update timeout"); + continue; + } + mobile_request_info = dynamic_cast<MobileRequestInfo*>(request_info.get()); + if (NULL == mobile_request_info) { + continue; + } + if (app_id == mobile_request_info->app_id_ && + mobile_correlation_id == mobile_request_info->mobile_correlation_id_) { + break; + } + } + + if (it != pending_request_set_.end()) { + DCHECK(mobile_request_info); + DCHECK(request_info.valid()); + + mobile_request_info->updateTimeOut(new_timeout); + pending_request_set_.erase(it); + pending_request_set_.insert(request_info); + // erase and insert need to update ordering of set + UpdateTimer(); + LOG4CXX_ERROR(logger_, "Timeout updated for " + << " app_id " << app_id + << " mobile_correlation_id " << mobile_correlation_id + << " new_timeout " << new_timeout); + } else { + LOG4CXX_ERROR(logger_, "Cant find request with " + << " app_id " << app_id + << " mobile_correlation_id " << mobile_correlation_id ); + } +} + +void RequestController::onTimer() { + LOG4CXX_TRACE_ENTER(logger_); + AutoLock auto_lock(pending_request_set_lock_); + RequestInfoSet::iterator probably_expired = pending_request_set_.begin(); + while (pending_request_set_.end() != probably_expired) { + RequestInfoPtr request = *probably_expired; + if (request->timeout_sec() == 0) { + LOG4CXX_INFO(logger_, "Ignore " << request->requestId()); + ++probably_expired; + // This request should not be observed for TIME_OUT + continue; + } + if (request->isExpired()) { + pending_request_set_.erase(probably_expired); + commands::CommandRequestImpl* mobile_expired_request = + dynamic_cast<commands::CommandRequestImpl*>(request->request()); + if (mobile_expired_request) { + + mobile_expired_request->onTimeOut(); + } + request->request()->CleanUp(); + LOG4CXX_INFO(logger_, "Timeout for request id " << request->requestId() << " expired"); + probably_expired = pending_request_set_.begin(); + break; + } + } + UpdateTimer(); + LOG4CXX_TRACE_EXIT(logger_); +} + +RequestController::Worker::Worker(RequestController* requestController) + : request_controller_(requestController) + , stop_flag_(false) { +} + +RequestController::Worker::~Worker() { +} + +void RequestController::Worker::threadMain() { + LOG4CXX_TRACE_ENTER(logger_); + sync_primitives::AutoLock auto_lock(thread_lock_); + while (!stop_flag_) { + // Try to pick a request + sync_primitives::AutoLock auto_lock(request_controller_->mobile_request_list_lock_); + + while ((request_controller_->pool_state_ != TPoolState::STOPPED) && + (request_controller_->mobile_request_list_.empty())) { + // Wait until there is a task in the queue + // Unlock mutex while wait, then lock it back when signaled + LOG4CXX_INFO(logger_, "Unlocking and waiting"); + request_controller_->cond_var_.Wait(auto_lock); + LOG4CXX_INFO(logger_, "Signaled and locking"); + } + + // If the thread was shutdown, return from here + if (request_controller_->pool_state_ == TPoolState::STOPPED) { + break; + } + + MobileRequestPtr request(request_controller_->mobile_request_list_.front()); + + request_controller_->mobile_request_list_.pop_front(); + bool init_res = request->Init(); // to setup specific default timeout + RequestInfoPtr request_info_ptr(new MobileRequestInfo(request, request->default_timeout())); + + request_controller_->pending_request_set_lock_.Acquire(); + request_controller_->pending_request_set_.insert(request_info_ptr); + //pending_request_list_.Acquire(); + if (0 != request->default_timeout()) { + LOG4CXX_INFO(logger_, "Add Request " << request_info_ptr->requestId() << + "with timeout: " << request->default_timeout()); + request_controller_->UpdateTimer(); + } else { + LOG4CXX_INFO(logger_, "Default timeout was set to 0." + "RequestController will not track timeout of this request."); + } + request_controller_->pending_request_set_lock_.Release(); + AutoUnlock unlock(auto_lock); + + // execute + if (request->CheckPermissions() && init_res) { + request->Run(); + } + } + +} + +bool RequestController::Worker::exitThreadMain() { + stop_flag_ = true; + sync_primitives::AutoLock auto_lock(thread_lock_); + // setup stop flag and whit while threadMain will be finished correctly + return true; +} + +bool RequestController::checkTimeScaleMaxRequest( + const uint32_t& app_id, + const uint32_t& app_time_scale, + const uint32_t& max_request_per_time_scale) { + LOG4CXX_TRACE_ENTER(logger_); + { + AutoLock auto_lock(pending_request_set_lock_); + TimevalStruct end = date_time::DateTime::getCurrentTime(); + TimevalStruct start; + start.tv_sec = end.tv_sec - app_time_scale; + + TimeScale scale(start, end, app_id); + uint32_t count = 0; + + count = count_if (pending_request_set_.begin(), pending_request_set_.end(), scale); + if (count == max_request_per_time_scale ) { + LOG4CXX_ERROR(logger_, "Requests count " << count << + " exceed application limit " << max_request_per_time_scale); + return true; + } + } + return true; +} + +bool RequestController::checkHMILevelTimeScaleMaxRequest( + const mobile_apis::HMILevel::eType& hmi_level, + const uint32_t& app_id, + const uint32_t& app_time_scale, + const uint32_t& max_request_per_time_scale) { + LOG4CXX_TRACE_ENTER(logger_); + { + AutoLock auto_lock(pending_request_set_lock_); + TimevalStruct end = date_time::DateTime::getCurrentTime(); + TimevalStruct start; + start.tv_sec = end.tv_sec - app_time_scale; + + HMILevelTimeScale scale(start, end, app_id, hmi_level); + uint32_t count = 0; + + count = count_if (pending_request_set_.begin(), pending_request_set_.end(), scale); + if (count == max_request_per_time_scale ) { + LOG4CXX_ERROR(logger_, "Requests count " << count + << " exceed application limit " << max_request_per_time_scale + << " in hmi level " << hmi_level); + return false; + } + } + return true; +} + +void RequestController::UpdateTimer() { + LOG4CXX_TRACE_ENTER(logger_); + uint32_t sleep_time = dafault_sleep_time_; + RequestInfoSet::iterator it = pending_request_set_.begin(); + + while (it != pending_request_set_.end()) { + RequestInfoPtr request = *it; + DCHECK(request.valid()); + if (0 == request->timeout_sec()) { + ++it; + // This request should not be observed for TIME_OUT + continue; + } + sleep_time = request->end_time().tv_sec - + date_time::DateTime::getCurrentTime().tv_sec; + break; + } + timer_.updateTimeOut(sleep_time); + LOG4CXX_INFO(logger_, "Sleep for: " << sleep_time); + LOG4CXX_TRACE_EXIT(logger_); +} + + +} // namespace request_controller + +} // namespace application_manager diff --git a/src/components/application_manager/src/request_info.cc b/src/components/application_manager/src/request_info.cc new file mode 100644 index 0000000000..58b939f857 --- /dev/null +++ b/src/components/application_manager/src/request_info.cc @@ -0,0 +1,83 @@ +/** +* \file request_info.h +* \brief request information structure source file. +* +* Copyright (c) 2014, Ford Motor Company +* 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 Ford Motor Company nor the names of its 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 "application_manager/request_info.h" +namespace application_manager { + +namespace request_controller { + +HMIRequestInfo::HMIRequestInfo( + RequestPtr request, + const uint64_t timeout_sec): + RequestInfo(timeout_sec), + request_(request) { + correlation_id_ = request_->correlation_id(); +} + +HMIRequestInfo::HMIRequestInfo( + RequestPtr request, + const TimevalStruct &start_time, + const uint64_t timeout_sec): + RequestInfo(start_time, timeout_sec), + request_(request) { + correlation_id_ = request_->correlation_id(); +} + +MobileRequestInfo::MobileRequestInfo( + MobileRequestPtr request, + const uint64_t timeout_sec): + RequestInfo(timeout_sec), + request_(request) { + commands::CommandRequestImpl* request_from_mobile = + static_cast<commands::CommandRequestImpl*>(request_.get()); + mobile_correlation_id_ = request_from_mobile->correlation_id(); + app_id_ = request_from_mobile->connection_key(); +} + +MobileRequestInfo::MobileRequestInfo( + MobileRequestPtr request, + const TimevalStruct &start_time, + const uint64_t timeout_sec): + RequestInfo(start_time, timeout_sec), + request_(request) { + commands::CommandRequestImpl* request_to_hmi = + static_cast<commands::CommandRequestImpl*>(request_.get()); + mobile_correlation_id_ = request_to_hmi->correlation_id(); + app_id_ = request_to_hmi->connection_key(); +} + +} // namespace request_controller + +} // namespace application_manager diff --git a/src/components/application_manager/src/resume_ctrl.cpp b/src/components/application_manager/src/resume_ctrl.cpp new file mode 100644 index 0000000000..dff90a6383 --- /dev/null +++ b/src/components/application_manager/src/resume_ctrl.cpp @@ -0,0 +1,941 @@ +#include <fstream> + +#include "application_manager/resume_ctrl.h" +#include "config_profile/profile.h" +#include "utils/file_system.h" +#include "connection_handler/connection_handler_impl.h" +#include "application_manager/application_manager_impl.h" +#include "application_manager/application.h" +#include "application_manager/message_helper.h" +#include "smart_objects/smart_object.h" +#include "connection_handler/connection.h" +#include "formatters/CFormatterJsonBase.hpp" +#include "application_manager/commands/command_impl.h" +#include "resumption/last_state.h" +#include "policy/policy_manager_impl.h" +#include "application_manager/policies/policy_handler.h" + +namespace application_manager { + +CREATE_LOGGERPTR_GLOBAL(logger_, "ResumeCtrl") + +namespace Formatters = NsSmartDeviceLink::NsJSONHandler::Formatters; + +ResumeCtrl::ResumeCtrl(ApplicationManagerImpl* app_mngr) + : app_mngr_(app_mngr), + timer_("ResumeCtrl", this, &ResumeCtrl::onTimer) { +} + +void ResumeCtrl::SaveAllApplications() { + LOG4CXX_INFO(logger_, "ResumeCtrl::SaveApplications()"); + DCHECK(app_mngr_); + + std::set<ApplicationSharedPtr>::iterator it = + app_mngr_->application_list_.begin(); + std::set<ApplicationSharedPtr>::iterator it_end = + app_mngr_->application_list_.end(); + for (; it != it_end; ++it) { + SaveApplication(*it); + } +} + +void ResumeCtrl::SaveApplication(ApplicationConstSharedPtr application) { + LOG4CXX_INFO(logger_, "ResumeCtrl::SaveApplication"); + + DCHECK(application.get()); + + Json::Value* json_app = NULL; + + const std::string& m_app_id = application->mobile_app_id()->asString(); + Json::Value::iterator it = GetSavedApplications().begin(); + for (; it != GetSavedApplications().end(); ++it) { + if (m_app_id == (*it)[strings::app_id].asString()) { + json_app = &(*it); + LOG4CXX_INFO(logger_, "ResumeCtrl Application with this id " + "already exist ( update info )." + "mobile app_id = " << m_app_id); + break; + } + } + + if (json_app == NULL) { + LOG4CXX_INFO(logger_, "ResumeCtrl Application with this ID does not" + "exist. Add new. mobile app_id = " << m_app_id); + json_app = &(GetSavedApplications().append(Json::Value())); + } + + uint32_t hash = application->curHash(); + uint32_t grammar_id = application->get_grammar_id(); + + LOG4CXX_INFO(logger_, "Hash = " << hash); + (*json_app)[strings::device_mac] = + MessageHelper::GetDeviceMacAddressForHandle(application->device()); + (*json_app)[strings::app_id] = m_app_id; + (*json_app)[strings::grammar_id] = grammar_id; + (*json_app)[strings::connection_key] = application->app_id(); + (*json_app)[strings::hmi_app_id] = application->hmi_app_id(); + (*json_app)[strings::hmi_level] = + static_cast<int32_t> (application->hmi_level()); + (*json_app)[strings::ign_off_count] = 0; + (*json_app)[strings::hash_id] = hash; + (*json_app)[strings::application_commands] = + GetApplicationCommands(application); + (*json_app)[strings::application_submenus] = + GetApplicationSubMenus(application); + (*json_app)[strings::application_choise_sets] = + GetApplicationInteractionChoiseSets(application); + (*json_app)[strings::application_global_properties] = + GetApplicationGlobalProperties(application); + (*json_app)[strings::application_subscribtions] = + GetApplicationSubscriptions(application); + (*json_app)[strings::application_files] = GetApplicationFiles(application); + (*json_app)[strings::time_stamp] = (uint32_t)time(NULL); + (*json_app)[strings::audio_streaming_state] = application->audio_streaming_state(); +} + +void ResumeCtrl::on_event(const event_engine::Event& event) { + LOG4CXX_INFO(logger_, "ResumeCtrl::on_event "); +} + +bool ResumeCtrl::RestoreApplicationHMILevel(ApplicationSharedPtr application) { + if (false == application.valid()) { + LOG4CXX_ERROR(logger_, " RestoreApplicationHMILevel() application pointer in invalid"); + return false; + } + Json::Value::iterator it = GetSavedApplications().begin(); + for (;it != GetSavedApplications().end(); ++it) { + const std::string& saved_m_app_id = (*it)[strings::app_id].asString(); + + if (saved_m_app_id == application->mobile_app_id()->asString()) { + + mobile_apis::HMILevel::eType saved_hmi_level; + //mobile_apis::HMILevel::eType restored_hmi_level; + + mobile_apis::AudioStreamingState::eType audio_streaming_state = + static_cast<mobile_apis::AudioStreamingState::eType> + ((*it)[strings::audio_streaming_state].asInt()); + application->set_audio_streaming_state(audio_streaming_state); + saved_hmi_level = static_cast<mobile_apis::HMILevel::eType>( + (*it)[strings::hmi_level].asInt()); + + return SetupHMILevel(application, saved_hmi_level, audio_streaming_state); + } + } + LOG4CXX_INFO(logger_, "Failed to restore application HMILevel"); + return false; +} + +bool ResumeCtrl::SetupDefaultHMILevel(ApplicationSharedPtr application) { + LOG4CXX_TRACE_ENTER(logger_); + if (false == application.valid()) { + LOG4CXX_ERROR(logger_, "SetupDefaultHMILevel application pointer is invalid"); + return false; + } + + mobile_apis::HMILevel::eType default_hmi = mobile_apis::HMILevel::HMI_NONE; + + if (policy::PolicyHandler::instance()->PolicyEnabled()) { + std::string policy_app_id = application->mobile_app_id()->asString(); + std::string default_hmi_string = ""; + bool result_get_hmi = policy::PolicyHandler::instance()->GetDefaultHmi( + policy_app_id, &default_hmi_string); + if (true == result_get_hmi) { + if ("BACKGROUND" == default_hmi_string) { + default_hmi = mobile_apis::HMILevel::HMI_BACKGROUND; + } else if ("FULL" == default_hmi_string) { + default_hmi = mobile_apis::HMILevel::HMI_FULL; + } else if ("LIMITED" == default_hmi_string) { + default_hmi = mobile_apis::HMILevel::HMI_LIMITED; + } else if ("NONE" == default_hmi_string) { + default_hmi = mobile_apis::HMILevel::HMI_NONE; + } else { + LOG4CXX_ERROR(logger_, "Unable to convert " + default_hmi_string + "to HMILevel"); + return false; + } + } else { + LOG4CXX_ERROR(logger_, "SetupDefaultHMILevel() unable to get default hmi_level for " + << policy_app_id); + } + } + + return SetupHMILevel(application, default_hmi, + mobile_apis::AudioStreamingState::NOT_AUDIBLE, false); +} + +bool ResumeCtrl::SetupHMILevel(ApplicationSharedPtr application, + mobile_apis::HMILevel::eType hmi_level, + mobile_apis::AudioStreamingState::eType audio_streaming_state, + bool check_policy) { + + if (false == application.valid()) { + LOG4CXX_ERROR(logger_, "SetupHMILevel() application pointer in invalid"); + return false; + } +#ifdef ENABLE_LOG + bool seted_up_hmi_level = hmi_level; +#endif + + const std::string device_id = + MessageHelper::GetDeviceMacAddressForHandle(application->device()); + + if (check_policy && + policy::PolicyHandler::instance()->GetUserConsentForDevice(device_id) + != policy::DeviceConsent::kDeviceAllowed) { + LOG4CXX_ERROR(logger_, "Resumption abort. Data consent wasn't allowed"); + SetupDefaultHMILevel(application); + return false; + } + + + if ((hmi_level == application->hmi_level()) && + (hmi_level != mobile_apis::HMILevel::HMI_NONE)) { + LOG4CXX_WARN(logger_, "Hmi level " << hmi_level << " should not be set to " + << application->mobile_app_id()->asString() << " " << application->hmi_level()); + + return false; + } + + if (hmi_level == mobile_apis::HMILevel::HMI_FULL) { +#ifdef ENABLE_LOG + seted_up_hmi_level = app_mngr_->PutApplicationInFull(application); +#else + app_mngr_->PutApplicationInFull(application); +#endif + } else if (hmi_level == mobile_apis::HMILevel::HMI_LIMITED) { +#ifdef ENABLE_LOG + seted_up_hmi_level = app_mngr_->PutApplicationInLimited(application); +#else + app_mngr_->PutApplicationInLimited(application); +#endif + if (audio_streaming_state == mobile_apis::AudioStreamingState::AUDIBLE) { + //implemented SDLAQ-CRS-839 + //checking the existence of application with AudioStreamingState=AUDIBLE + //notification resumeAudioSource is sent if only resumed application has + //AudioStreamingState=AUDIBLE + bool application_exist_with_audible_state = false; + ApplicationManagerImpl::ApplicationListAccessor accessor; + const std::set<ApplicationSharedPtr> app_list = accessor.applications(); + std::set<ApplicationSharedPtr>::const_iterator app_list_it = app_list.begin(); + uint32_t app_id = application->app_id(); + for (; app_list.end() != app_list_it; ++app_list_it) { + if (((*app_list_it)->audio_streaming_state() == + mobile_apis::AudioStreamingState::AUDIBLE) && + ((*app_list_it))->app_id() != app_id) { + application_exist_with_audible_state = true; + break; + } + } + if (application_exist_with_audible_state) { + application->set_audio_streaming_state( + mobile_apis::AudioStreamingState::NOT_AUDIBLE); + } else { + MessageHelper::SendOnResumeAudioSourceToHMI(application->app_id()); + } + } + } + application->set_hmi_level(hmi_level); + if (hmi_level != mobile_apis::HMILevel::HMI_FULL) { + //APPLINK-7244 + MessageHelper::SendHMIStatusNotification(*(application.get())); + } + + LOG4CXX_INFO(logger_, "Set up application " + << application->mobile_app_id()->asString() + << " to HMILevel " << seted_up_hmi_level); + return true; +} + +bool ResumeCtrl::RestoreApplicationData(ApplicationSharedPtr application) { + LOG4CXX_INFO(logger_, "RestoreApplicationData"); + DCHECK(application.get()); + + Json::Value::iterator it = GetSavedApplications().begin(); + for (; it != GetSavedApplications().end(); ++it) { + const std::string& saved_m_app_id = (*it)[strings::app_id].asString(); + if (saved_m_app_id == application->mobile_app_id()->asString()) { + break; + } + } + + if (it == GetSavedApplications().end()) { + LOG4CXX_WARN(logger_, "Application not saved"); + return false; + } + + Json::Value& saved_app = *it; + MessageHelper::SmartObjectList requests; + + LOG4CXX_INFO(logger_, saved_app.toStyledString()); + Json::Value& app_commands = saved_app[strings::application_commands]; + Json::Value& app_submenus = saved_app[strings::application_submenus]; + Json::Value& app_choise_sets = saved_app[strings::application_choise_sets]; + Json::Value& global_properties = saved_app[strings::application_global_properties]; + Json::Value& subscribtions = saved_app[strings::application_subscribtions]; + Json::Value& application_files = saved_app[strings::application_files]; + uint32_t app_grammar_id = saved_app[strings::grammar_id].asUInt(); + application->set_grammar_id(app_grammar_id); + + + // files + for (Json::Value::iterator json_it = application_files.begin(); + json_it != application_files.end(); ++json_it) { + Json::Value& file_data = *json_it; + + bool is_persistent = file_data[strings::persistent_file].asBool(); + if (is_persistent) { + AppFile file; + file.is_persistent = is_persistent; + file.is_download_complete = file_data[strings::is_download_complete].asBool(); + file.file_name = file_data[strings::sync_file_name].asString(); + file.file_type = static_cast<mobile_apis::FileType::eType> ( + file_data[strings::file_type].asInt()); + LOG4CXX_INFO(logger_, "RestoreApplicationData file " << file.file_name); + application->AddFile(file); + } + } + + //add submenus + for (Json::Value::iterator json_it = app_submenus.begin(); + json_it != app_submenus.end(); ++json_it) { + Json::Value& json_submenu = *json_it; + smart_objects::SmartObject message = smart_objects::SmartObject( + smart_objects::SmartType::SmartType_Map); + Formatters::CFormatterJsonBase::jsonValueToObj(json_submenu, message); + application->AddSubMenu(message[strings::menu_id].asUInt(), message); + } + requests = MessageHelper::CreateAddSubMenuRequestToHMI(application); + + for (MessageHelper::SmartObjectList::iterator it = requests.begin(); + it != requests.end(); ++it) { + ProcessHMIRequest(*it, true); + } + + //add commands + for (Json::Value::iterator json_it = app_commands.begin(); + json_it != app_commands.end(); ++json_it) { + Json::Value& json_command = *json_it; + smart_objects::SmartObject message = smart_objects::SmartObject( + smart_objects::SmartType::SmartType_Map); + Formatters::CFormatterJsonBase::jsonValueToObj(json_command, message); + application->AddCommand(message[strings::cmd_id].asUInt(), message); + } + + requests = MessageHelper::CreateAddCommandRequestToHMI(application); + + for (MessageHelper::SmartObjectList::iterator it = requests.begin(); + it != requests.end(); ++it) { + ProcessHMIRequest(*it, true); + } + + //add choisets + for (Json::Value::iterator json_it = app_choise_sets.begin(); + json_it != app_choise_sets.end(); ++json_it) { + Json::Value& json_choiset = *json_it; + smart_objects::SmartObject msg_param = smart_objects::SmartObject( + smart_objects::SmartType::SmartType_Map); + Formatters::CFormatterJsonBase::jsonValueToObj(json_choiset , msg_param); + const int32_t choice_set_id = msg_param + [strings::interaction_choice_set_id].asInt(); + uint32_t choice_grammar_id = msg_param[strings::grammar_id].asUInt(); + application->AddChoiceSet(choice_set_id, msg_param); + + for (size_t j = 0; j < msg_param[strings::choice_set].length(); ++j) { + smart_objects::SmartObject choise_params = smart_objects::SmartObject( + smart_objects::SmartType_Map); + choise_params[strings::app_id] = application->app_id(); + choise_params[strings::cmd_id] = + msg_param[strings::choice_set][j][strings::choice_id]; + choise_params[strings::vr_commands] = smart_objects::SmartObject( + smart_objects::SmartType_Array); + choise_params[strings::vr_commands] = + msg_param[strings::choice_set][j][strings::vr_commands]; + + choise_params[strings::type] = hmi_apis::Common_VRCommandType::Choice; + choise_params[strings::grammar_id] = choice_grammar_id; + SendHMIRequest(hmi_apis::FunctionID::VR_AddCommand, &choise_params); + } + } + + //setglobal properties + if (!global_properties.isNull()) { + smart_objects::SmartObject properties_so = smart_objects::SmartObject( + smart_objects::SmartType::SmartType_Map); + Formatters::CFormatterJsonBase::jsonValueToObj(global_properties , properties_so); + + const smart_objects::SmartObject& vr_help_title = + properties_so.getElement(strings::vr_help_title); + if (vr_help_title.getType() != smart_objects::SmartType::SmartType_Invalid && + vr_help_title.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_vr_help_title(vr_help_title); + } + + const smart_objects::SmartObject& vr_help = + properties_so.getElement(strings::vr_help); + if (vr_help.getType() != smart_objects::SmartType::SmartType_Invalid && + vr_help.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_vr_help(vr_help); + } + + const smart_objects::SmartObject& timeout_prompt = + properties_so.getElement(strings::timeout_prompt); + if (timeout_prompt.getType() != smart_objects::SmartType::SmartType_Invalid && + timeout_prompt.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_timeout_prompt(timeout_prompt); + } + + const smart_objects::SmartObject& help_prompt = + properties_so.getElement(strings::help_prompt); + if (help_prompt.getType() != smart_objects::SmartType::SmartType_Invalid && + help_prompt.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_help_prompt(help_prompt); + } + + const smart_objects::SmartObject& keyboard_properties = + properties_so.getElement(strings::keyboard_properties); + if (keyboard_properties.getType() != smart_objects::SmartType::SmartType_Invalid && + keyboard_properties.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_keyboard_props(keyboard_properties); + } + + const smart_objects::SmartObject& menu_title = + properties_so.getElement(strings::menu_title); + if (menu_title.getType() != smart_objects::SmartType::SmartType_Invalid && + menu_title.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_menu_title(menu_title); + } + + const smart_objects::SmartObject& menu_icon = + properties_so.getElement(strings::menu_icon); + if (menu_icon.getType() != smart_objects::SmartType::SmartType_Invalid && + menu_icon.getType() != smart_objects::SmartType::SmartType_Null) { + application->set_menu_icon(menu_icon); + } + + MessageHelper::SendGlobalPropertiesToHMI(application); + } + + //subscribes + if (!subscribtions.isNull()) { + Json::Value& subscribtions_buttons = subscribtions[strings::application_buttons]; + Json::Value& subscribtions_ivi= subscribtions[strings::application_vehicle_info]; + for (Json::Value::iterator json_it = subscribtions_buttons.begin(); + json_it != subscribtions_buttons.end(); ++json_it) { + mobile_apis::ButtonName::eType btn; + btn = static_cast<mobile_apis::ButtonName::eType>((*json_it).asInt()); + application->SubscribeToButton(btn); + } + + for (Json::Value::iterator json_it = subscribtions_ivi.begin(); + json_it != subscribtions_ivi.end(); ++json_it) { + VehicleDataType ivi; + ivi = static_cast<VehicleDataType>((*json_it).asInt()); + LOG4CXX_INFO(logger_, "VehicleDataType :" << ivi); +#ifdef ENABLE_LOG + bool result = +#endif + application->SubscribeToIVI(ivi); + LOG4CXX_INFO(logger_, "result = :" << result); + } + requests = MessageHelper::GetIVISubscribtionRequests(application->app_id()); + + for (MessageHelper::SmartObjectList::iterator it = requests.begin(); + it != requests.end(); ++it) { + ProcessHMIRequest(*it,true); + } + } + return true; +} + +bool ResumeCtrl::IsHMIApplicationIdExist(uint32_t hmi_app_id) { + LOG4CXX_INFO(logger_, "ResumeCtrl::IsHMIApplicationIdExist " << hmi_app_id); + + for (Json::Value::iterator it = GetSavedApplications().begin(); + it != GetSavedApplications().end(); ++it) { + if ((*it)[strings::hmi_app_id].asUInt() == hmi_app_id) { + return true; + } + } + + std::set<ApplicationSharedPtr>::iterator it = + app_mngr_->application_list_.begin(); + std::set<ApplicationSharedPtr>::iterator it_end = + app_mngr_->application_list_.end(); + for (;it != it_end; ++it) { + if (hmi_app_id == (*it)->hmi_app_id()) { + return true; + } + } + + return false; +} + +bool ResumeCtrl::IsApplicationSaved(const std::string& mobile_app_id) { + bool result = false; + for (Json::Value::iterator it = GetSavedApplications().begin(); + it != GetSavedApplications().end(); ++it) { + if ((*it)[strings::app_id].asString() == mobile_app_id) { + result = true; + } + } + LOG4CXX_INFO(logger_, "IsApplicationSaved " << mobile_app_id << " : " << (result?"true":"false")); + return result; +} + +uint32_t ResumeCtrl::GetHMIApplicationID(const std::string& mobile_app_id) { + uint32_t hmi_app_id = 0; + for (Json::Value::iterator it = GetSavedApplications().begin(); + it != GetSavedApplications().end(); ++it) { + if ((*it)[strings::app_id].asString() == mobile_app_id) { + hmi_app_id = (*it)[strings::hmi_app_id].asUInt(); + } + } + + return hmi_app_id; +} + +bool ResumeCtrl::RemoveApplicationFromSaved(ApplicationConstSharedPtr application) { + LOG4CXX_INFO(logger_, "ResumeCtrl::RemoveApplicationFromSaved "); + DCHECK(application.get()); + + bool result = false; + std::vector<Json::Value> temp; + for (Json::Value::iterator it = GetSavedApplications().begin(); + it != GetSavedApplications().end(); ++it) { + const std::string& saved_m_app_id = (*it)[strings::app_id].asString(); + + if (saved_m_app_id != application->mobile_app_id()->asString()) { + temp.push_back((*it)); + } else { + result = true; + } + } + + if (false == result) { + return result; + } + + GetSavedApplications().clear(); + for (std::vector<Json::Value>::iterator it = temp.begin(); + it != temp.end(); ++it) { + GetSavedApplications().append((*it)); + } + return result; +} + +void ResumeCtrl::IgnitionOff() { + LOG4CXX_INFO(logger_, "ResumeCtrl::IgnitionOff()"); + + Json::Value to_save; + for (Json::Value::iterator it = GetSavedApplications().begin(); + it != GetSavedApplications().end(); ++it) { + uint32_t ign_off_count = (*it)[strings::ign_off_count].asUInt(); + if (ign_off_count < kApplicationLifes) { + ign_off_count++; + (*it)[strings::ign_off_count] = ign_off_count; + to_save.append(*it); + } + } + SetSavedApplication(to_save); +} + +bool ResumeCtrl::StartResumption(ApplicationSharedPtr application, + uint32_t hash) { + LOG4CXX_INFO(logger_, "ResumeCtrl::StartResumption"); + if (!application.valid()) { + LOG4CXX_WARN(logger_, "Application not exist"); + return false; + } + + LOG4CXX_INFO(logger_, " app_id = " << application->app_id() + << " hmi_app_id = " << application->hmi_app_id() + << " mobile_id = " + << application->mobile_app_id()->asString()); + + Json::Value::iterator it = GetSavedApplications().begin(); + ApplicationManagerImpl::ApplicationListAccessor accessor; + for (; it != GetSavedApplications().end(); ++it) { + const std::string& saved_m_app_id = (*it)[strings::app_id].asString(); + + if (saved_m_app_id == application->mobile_app_id()->asString()) { + + uint32_t saved_hash = (*it)[strings::hash_id].asUInt(); + uint32_t time_stamp= (*it)[strings::time_stamp].asUInt(); + + if (hash == saved_hash) { + RestoreApplicationData(application); + } + + application->UpdateHash(); + if (!timer_.isRunning() && accessor.applications().size() > 1) { + RestoreApplicationHMILevel(application); + RemoveApplicationFromSaved(application); + } else { + sync_primitives::AutoLock auto_lock(queue_lock_); + SetupDefaultHMILevel(application); + waiting_for_timer_.insert(std::make_pair(application->app_id(), + time_stamp)); + timer_.start(kTimeStep); + } + return true; + } + } + + LOG4CXX_INFO(logger_, "ResumeCtrl::Application wasn't saved"); + MessageHelper::SendHMIStatusNotification(*application); + return false; +} + +bool ResumeCtrl::StartResumptionOnlyHMILevel(ApplicationSharedPtr application) { + LOG4CXX_INFO(logger_, "ResumeCtrl::StartResumptionOnlyHMILevel"); + if (!application.valid()) { + LOG4CXX_WARN(logger_, "Application not exist"); + return false; + } + + LOG4CXX_INFO(logger_, "app_id = " << application->app_id() + << "mobile_id = " + << application->mobile_app_id()->asString()); + + Json::Value::iterator it = GetSavedApplications().begin(); + ApplicationManagerImpl::ApplicationListAccessor accessor; + for (; it != GetSavedApplications().end(); ++it) { + const std::string& saved_m_app_id = (*it)[strings::app_id].asString(); + if (saved_m_app_id == application->mobile_app_id()->asString()) { + uint32_t time_stamp= (*it)[strings::time_stamp].asUInt(); + if (!timer_.isRunning() && accessor.applications().size() > 1) { + // resume in case there is already registered app + RestoreApplicationHMILevel(application); + RemoveApplicationFromSaved(application); + } else { + sync_primitives::AutoLock auto_lock(queue_lock_); + SetupDefaultHMILevel(application); + waiting_for_timer_.insert(std::make_pair(application->app_id(), + time_stamp)); + // woun't start timer if it is active already + timer_.start(kTimeStep); + } + return true; + } + } + + LOG4CXX_INFO(logger_, "ResumeCtrl::Application wasn't saved"); + MessageHelper::SendHMIStatusNotification(*application); + return false; +} + +bool ResumeCtrl::CheckPersistenceFilesForResumption(ApplicationSharedPtr application) { + LOG4CXX_INFO(logger_, "CheckPersistenceFilesForResumption"); + DCHECK(application.get()); + + Json::Value::iterator it = GetSavedApplications().begin(); + for (; it != GetSavedApplications().end(); ++it) { + const std::string& saved_m_app_id = (*it)[strings::app_id].asString(); + + if (saved_m_app_id == application->mobile_app_id()->asString()) { + break; + } + } + + if (it == GetSavedApplications().end()) { + LOG4CXX_WARN(logger_, "Application not saved"); + return false; + } + + Json::Value& saved_app = *it; + MessageHelper::SmartObjectList requests; + + LOG4CXX_INFO(logger_, saved_app.toStyledString()); + Json::Value& app_commands = saved_app[strings::application_commands]; + Json::Value& app_choise_sets = saved_app[strings::application_choise_sets]; + + //add commands + for (Json::Value::iterator json_it = app_commands.begin(); + json_it != app_commands.end(); ++json_it) { + Json::Value& json_command = *json_it; + smart_objects::SmartObject message = + smart_objects::SmartObject(smart_objects::SmartType::SmartType_Map); + Formatters::CFormatterJsonBase::jsonValueToObj(json_command, message); + mobile_apis::Result::eType verification_result = + MessageHelper::VerifyImageFiles(message, application); + if (verification_result == mobile_apis::Result::INVALID_DATA) { + LOG4CXX_WARN(logger_, "app_commands missed icons"); + return false; + } + } + + //add choice sets + for (Json::Value::iterator json_it = app_choise_sets.begin(); + json_it != app_choise_sets.end(); ++json_it) { + Json::Value& json_choiset = *json_it; + smart_objects::SmartObject msg_param = + smart_objects::SmartObject(smart_objects::SmartType::SmartType_Map); + Formatters::CFormatterJsonBase::jsonValueToObj(json_choiset , msg_param); + mobile_apis::Result::eType verification_result = + MessageHelper::VerifyImageFiles(msg_param, application); + if (verification_result == mobile_apis::Result::INVALID_DATA) { + LOG4CXX_WARN(logger_, "app_choise_sets missed icons"); + return false; + } + } + + return true; +} + +bool ResumeCtrl::CheckApplicationHash(ApplicationSharedPtr application, + uint32_t hash) { + Json::Value::iterator it = GetSavedApplications().begin(); + for (; it != GetSavedApplications().end(); ++it) { + std::string saved_m_app_id = (*it)[strings::app_id].asString(); + + if (saved_m_app_id == application->mobile_app_id()->asString()) { + uint32_t saved_hash = (*it)[strings::hash_id].asUInt(); + LOG4CXX_INFO(logger_, "received hash = " << hash); + LOG4CXX_INFO(logger_, "saved hash = " << saved_hash); + if (hash == saved_hash) { + return true; + } + } + } + + return false; +} + +void ResumeCtrl::onTimer() { + LOG4CXX_INFO(logger_, "ResumeCtrl::onTimer() size is " + << waiting_for_timer_.size()); + sync_primitives::AutoLock auto_lock(queue_lock_); + + std::multiset<application_timestamp, TimeStampComparator>::iterator it= + waiting_for_timer_.begin(); + + for (; it != waiting_for_timer_.end(); ++it) { + ApplicationSharedPtr app = + ApplicationManagerImpl::instance()->application((*it).first); + if (!app.get()) { + LOG4CXX_ERROR(logger_, "Invalid app_id = " << (*it).first); + continue; + } + + RestoreApplicationHMILevel(app); + RemoveApplicationFromSaved(app); + } + + waiting_for_timer_.clear(); +} + +bool ResumeCtrl::IsDeviceMacAddressEqual(ApplicationSharedPtr application, + const std::string& saved_device_mac) { + const std::string device_mac = + MessageHelper::GetDeviceMacAddressForHandle(application->device()); + + return device_mac == saved_device_mac; +} + +Json::Value& ResumeCtrl::GetSavedApplications() { + return resumption::LastState::instance()->dictionary[strings::resumption]; +} + +void ResumeCtrl::SetSavedApplication(Json::Value& apps_json) { + resumption::LastState::instance()->dictionary[strings::resumption] = apps_json ; +} + +void ResumeCtrl::ClearResumptionInfo() { + Json::Value empty_json; + + SetSavedApplication(empty_json); + resumption::LastState::instance()->SaveToFileSystem(); +} + +Json::Value ResumeCtrl::GetApplicationCommands( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationCommands " + << application->app_id()); + + Json::Value result; + const CommandsMap& commands = application->commands_map(); + CommandsMap::const_iterator it = commands.begin(); + for (;it != commands.end(); ++it) { + smart_objects::SmartObject* so = it->second; + Json::Value curr; + Formatters::CFormatterJsonBase::objToJsonValue(*so, curr); + result.append(curr); + LOG4CXX_INFO(logger_, "Converted:" << curr.toStyledString()); + } + return result; +} + +Json::Value ResumeCtrl::GetApplicationSubMenus( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationCommands " + << application->app_id()); + + Json::Value result; + const SubMenuMap& sub_menus = application->sub_menu_map(); + SubMenuMap::const_iterator it = sub_menus.begin(); + for (;it != sub_menus.end(); ++it) { + smart_objects::SmartObject* so = it->second; + Json::Value curr; + Formatters::CFormatterJsonBase::objToJsonValue(*so, curr); + result.append(curr); + LOG4CXX_INFO(logger_, "Converted:" << curr.toStyledString()); + } + return result; +} + +Json::Value ResumeCtrl::GetApplicationInteractionChoiseSets( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationInteractionChoiseSets " + << application->app_id()); + + Json::Value result; + const ChoiceSetMap& choices = application->choice_set_map(); + ChoiceSetMap::const_iterator it = choices.begin(); + for ( ;it != choices.end(); ++it) { + smart_objects::SmartObject* so = it->second; + Json::Value curr; + Formatters::CFormatterJsonBase::objToJsonValue(*so, curr); + result.append(curr); + LOG4CXX_INFO(logger_, "Converted:" << curr.toStyledString()); + } + return result; +} + +Json::Value ResumeCtrl::GetApplicationGlobalProperties( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationGlobalProperties " + << application->app_id()); + + Json::Value result; + const smart_objects::SmartObject* help_promt = application->help_prompt(); + const smart_objects::SmartObject* timeout_prompt = application->timeout_prompt(); + const smart_objects::SmartObject* vr_help = application->vr_help(); + const smart_objects::SmartObject* vr_help_title = application->vr_help_title(); + const smart_objects::SmartObject* vr_synonyms = application->vr_synonyms(); + const smart_objects::SmartObject* keyboard_props = application->keyboard_props(); + const smart_objects::SmartObject* menu_title = application->menu_title(); + const smart_objects::SmartObject* menu_icon = application->menu_icon(); + + Json::Value sgp; + sgp[strings::help_prompt] = JsonFromSO(help_promt); + sgp[strings::timeout_prompt] = JsonFromSO(timeout_prompt); + sgp[strings::vr_help] = JsonFromSO(vr_help); + sgp[strings::vr_help_title] = JsonFromSO(vr_help_title); + sgp[strings::vr_synonyms] = JsonFromSO(vr_synonyms); + sgp[strings::keyboard_properties] = JsonFromSO(keyboard_props); + sgp[strings::menu_title] = JsonFromSO(menu_title); + sgp[strings::menu_icon] = JsonFromSO(menu_icon); + + return sgp; +} + +Json::Value ResumeCtrl::GetApplicationSubscriptions( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationSubscriptions " + << application->app_id()); + + Json::Value result; + std::set<mobile_apis::ButtonName::eType>::iterator it_button ; + std::set<uint32_t>::iterator it_vehicle; + + for (it_button = application->SubscribedButtons().begin() ; + it_button != application->SubscribedButtons().end(); ++it_button) { + result[strings::application_buttons].append(*it_button); + } + for (it_vehicle = application->SubscribesIVI().begin(); + it_vehicle != application->SubscribesIVI().end(); ++it_vehicle) { + result[strings::application_vehicle_info].append(*it_vehicle); + } + return result; +} + +Json::Value ResumeCtrl::GetApplicationFiles( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationFiles " + << application->app_id()); + + Json::Value result; + const AppFilesMap& app_files = application->getAppFiles(); + for(AppFilesMap::const_iterator file_it = app_files.begin(); + file_it != app_files.end(); file_it++) { + const AppFile& file = file_it->second; + if (file.is_persistent) { + Json::Value file_data; + file_data[strings::persistent_file] = file.is_persistent; + file_data[strings::is_download_complete] = file.is_download_complete; + file_data[strings::sync_file_name] = file.file_name; + file_data[strings::file_type] = file.file_type; + result.append(file_data); + } + } + return result; +} + +Json::Value ResumeCtrl::GetApplicationShow( + ApplicationConstSharedPtr application) { + DCHECK(application.get()); + LOG4CXX_INFO(logger_, "ResumeCtrl::GetApplicationShow " + << application->app_id()); + + Json::Value result; + const smart_objects::SmartObject* show_so = application->show_command(); + if (!show_so) { + return result; + } + result = JsonFromSO(show_so); + return result; +} + +Json::Value ResumeCtrl::JsonFromSO(const smart_objects::SmartObject *so) { + Json::Value temp; + if (so) { + Formatters::CFormatterJsonBase::objToJsonValue(*so, temp); + } + return temp; +} + +bool ResumeCtrl::ProcessHMIRequest(smart_objects::SmartObject* request, + bool use_events) { + if (use_events) { + const hmi_apis::FunctionID::eType function_id = + static_cast<hmi_apis::FunctionID::eType>( + (*request)[strings::function_id].asInt()); + + const int32_t hmi_correlation_id = + (*request)[strings::correlation_id].asInt(); + subscribe_on_event(function_id, hmi_correlation_id); + } + if (!ApplicationManagerImpl::instance()->ManageHMICommand(request)) { + LOG4CXX_ERROR(logger_, "Unable to send request"); + return true; + } + return false; +} + +void ResumeCtrl::SendHMIRequest( + const hmi_apis::FunctionID::eType& function_id, + const smart_objects::SmartObject* msg_params, bool use_events) { + + NsSmartDeviceLink::NsSmartObjects::SmartObject* result = + MessageHelper::CreateModuleInfoSO(function_id); + int32_t hmi_correlation_id = + (*result)[strings::params][strings::correlation_id].asInt(); + if (use_events) { + subscribe_on_event(function_id, hmi_correlation_id); + } + + if (msg_params) { + (*result)[strings::msg_params] = *msg_params; + } + + if (!ApplicationManagerImpl::instance()->ManageHMICommand(result)) { + LOG4CXX_ERROR(logger_, "Unable to send request"); + } +} + +} // namespace application_manager diff --git a/src/components/application_manager/src/usage_statistics.cc b/src/components/application_manager/src/usage_statistics.cc new file mode 100644 index 0000000000..44ab164538 --- /dev/null +++ b/src/components/application_manager/src/usage_statistics.cc @@ -0,0 +1,125 @@ +/** + * Copyright (c) 2014, Ford Motor Company + * 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 Ford Motor Company nor the names of its 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 "application_manager/usage_statistics.h" + +#include "smart_objects/smart_object.h" +#include "smart_objects/enum_schema_item.h" +#include "usage_statistics/statistics_manager.h" +#include "utils/macro.h" + +using namespace mobile_apis; +using namespace NsSmartDeviceLink::NsSmartObjects; +using namespace usage_statistics; + +namespace application_manager { + +namespace { + +std::string LanguageIdToString(Language::eType lang_id) { + const char* str; + const bool ok = EnumConversionHelper<Language::eType>::EnumToCString(lang_id, &str); + return ok ? str : "unknown"; +} + +} // namespace + +UsageStatistics::UsageStatistics(const std::string& app_id, + utils::SharedPtr<usage_statistics::StatisticsManager> statistics_manager) + : time_in_hmi_state_(statistics_manager, app_id), + app_registration_language_gui_(statistics_manager, app_id, LANGUAGE_GUI), + app_registration_language_vui_(statistics_manager, app_id, LANGUAGE_VUI), + count_of_rejected_rpc_calls_(statistics_manager, app_id, + REJECTED_RPC_CALLS), + count_of_rpcs_sent_in_hmi_none_(statistics_manager, app_id, + RPCS_IN_HMI_NONE), + count_of_user_selections_(statistics_manager, app_id, USER_SELECTIONS), + count_of_run_attempts_while_revoked_(statistics_manager, app_id, + RUN_ATTEMPTS_WHILE_REVOKED), + count_of_removals_for_bad_behavior_(statistics_manager, app_id, + REMOVALS_MISBEHAVED) { + time_in_hmi_state_.Start(SECONDS_HMI_NONE); +} + +void UsageStatistics::RecordHmiStateChanged(HMILevel::eType new_hmi_level) { + using namespace mobile_apis::HMILevel; + AppStopwatchId next_stopwatch = SECONDS_HMI_NONE; + switch (new_hmi_level) { + case HMI_FULL: + next_stopwatch = SECONDS_HMI_FULL; + break; + case HMI_LIMITED: + next_stopwatch = SECONDS_HMI_LIMITED; + break; + case HMI_BACKGROUND: + next_stopwatch = SECONDS_HMI_BACKGROUND; + break; + case HMI_NONE: + next_stopwatch = SECONDS_HMI_NONE; + break; + default: + NOTREACHED(); + } + time_in_hmi_state_.Switch(next_stopwatch); +} + +void UsageStatistics::RecordAppRegistrationGuiLanguage( + Language::eType gui_language) { + app_registration_language_gui_.Update(LanguageIdToString(gui_language)); +} + +void UsageStatistics::RecordAppRegistrationVuiLanguage( + Language::eType vui_language) { + app_registration_language_gui_.Update(LanguageIdToString(vui_language)); +} + +void UsageStatistics::RecordRpcSentInHMINone() { + ++count_of_rpcs_sent_in_hmi_none_; +} + +void UsageStatistics::RecordPolicyRejectedRpcCall() { + ++count_of_rejected_rpc_calls_; +} + +void UsageStatistics::RecordAppUserSelection() { + ++count_of_user_selections_; +} + +void UsageStatistics::RecordRunAttemptsWhileRevoked() { + ++count_of_run_attempts_while_revoked_; +} + +void UsageStatistics::RecordRemovalsForBadBehavior() { + ++count_of_removals_for_bad_behavior_; +} + +} // namespace application_manager |