diff options
Diffstat (limited to 'src/components/application_manager/src/hmi_capabilities_impl.cc')
-rw-r--r-- | src/components/application_manager/src/hmi_capabilities_impl.cc | 1332 |
1 files changed, 1104 insertions, 228 deletions
diff --git a/src/components/application_manager/src/hmi_capabilities_impl.cc b/src/components/application_manager/src/hmi_capabilities_impl.cc index 874d1cb015..b1b81f2b7d 100644 --- a/src/components/application_manager/src/hmi_capabilities_impl.cc +++ b/src/components/application_manager/src/hmi_capabilities_impl.cc @@ -30,17 +30,22 @@ * POSSIBILITY OF SUCH DAMAGE. */ +#include "application_manager/hmi_capabilities_impl.h" + #include <map> #include "application_manager/application_manager.h" -#include "application_manager/hmi_capabilities_impl.h" #include "application_manager/message_helper.h" +#include "application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h" #include "application_manager/smart_object_keys.h" #include "config_profile/profile.h" #include "formatters/CFormatterJsonBase.h" #include "interfaces/HMI_API.h" +#include "smart_objects/enum_schema_item.h" #include "smart_objects/smart_object.h" #include "utils/file_system.h" +#include "utils/helpers.h" +#include "utils/jsoncpp_reader_wrapper.h" #include "utils/logger.h" namespace application_manager { @@ -53,6 +58,8 @@ std::map<std::string, hmi_apis::Common_VrCapabilities::eType> vr_enum_capabilities; std::map<std::string, hmi_apis::Common_SpeechCapabilities::eType> tts_enum_capabilities; +std::map<std::string, hmi_apis::Common_PrerecordedSpeech::eType> + tts_enum_prerecorded_speech; std::map<std::string, hmi_apis::Common_ButtonName::eType> button_enum_name; std::map<std::string, hmi_apis::Common_TextFieldName::eType> text_fields_enum_name; @@ -98,6 +105,22 @@ void InitCapabilities() { tts_enum_capabilities.insert(std::make_pair( std::string("FILE"), hmi_apis::Common_SpeechCapabilities::FILE)); + tts_enum_prerecorded_speech.insert( + std::make_pair(std::string("HELP_JINGLE"), + hmi_apis::Common_PrerecordedSpeech::HELP_JINGLE)); + tts_enum_prerecorded_speech.insert( + std::make_pair(std::string("INITIAL_JINGLE"), + hmi_apis::Common_PrerecordedSpeech::INITIAL_JINGLE)); + tts_enum_prerecorded_speech.insert( + std::make_pair(std::string("LISTEN_JINGLE"), + hmi_apis::Common_PrerecordedSpeech::LISTEN_JINGLE)); + tts_enum_prerecorded_speech.insert( + std::make_pair(std::string("POSITIVE_JINGLE"), + hmi_apis::Common_PrerecordedSpeech::POSITIVE_JINGLE)); + tts_enum_prerecorded_speech.insert( + std::make_pair(std::string("NEGATIVE_JINGLE"), + hmi_apis::Common_PrerecordedSpeech::NEGATIVE_JINGLE)); + button_enum_name.insert( std::make_pair(std::string("OK"), hmi_apis::Common_ButtonName::OK)); button_enum_name.insert(std::make_pair( @@ -255,6 +278,15 @@ void InitCapabilities() { hmi_apis::Common_TextFieldName::addressLines)); text_fields_enum_name.insert(std::make_pair( std::string("phoneNumber"), hmi_apis::Common_TextFieldName::phoneNumber)); + text_fields_enum_name.insert( + std::make_pair(std::string("subtleAlertText1"), + hmi_apis::Common_TextFieldName::subtleAlertText1)); + text_fields_enum_name.insert( + std::make_pair(std::string("subtleAlertText2"), + hmi_apis::Common_TextFieldName::subtleAlertText2)); + text_fields_enum_name.insert(std::make_pair( + std::string("subtleAlertSoftButtonText"), + hmi_apis::Common_TextFieldName::subtleAlertSoftButtonText)); text_fields_enum_name.insert(std::make_pair( std::string("turnText"), hmi_apis::Common_TextFieldName::turnText)); text_fields_enum_name.insert(std::make_pair( @@ -341,6 +373,9 @@ void InitCapabilities() { hmi_apis::Common_ImageFieldName::locationImage)); image_field_name_enum.insert(std::make_pair( std::string("alertIcon"), hmi_apis::Common_ImageFieldName::alertIcon)); + image_field_name_enum.insert( + std::make_pair(std::string("subtleAlertIcon"), + hmi_apis::Common_ImageFieldName::subtleAlertIcon)); file_type_enum.insert(std::make_pair(std::string("GRAPHIC_BMP"), hmi_apis::Common_FileType::GRAPHIC_BMP)); @@ -390,6 +425,12 @@ void InitCapabilities() { std::string("CID1SET"), hmi_apis::Common_CharacterSet::CID1SET)); character_set_enum.insert(std::make_pair( std::string("CID2SET"), hmi_apis::Common_CharacterSet::CID2SET)); + character_set_enum.insert(std::make_pair( + std::string("ASCII"), hmi_apis::Common_CharacterSet::ASCII)); + character_set_enum.insert(std::make_pair( + std::string("ISO_8859_1"), hmi_apis::Common_CharacterSet::ISO_8859_1)); + character_set_enum.insert(std::make_pair( + std::string("UTF_8"), hmi_apis::Common_CharacterSet::UTF_8)); video_streaming_protocol_enum.insert(std::make_pair( std::string("RAW"), hmi_apis::Common_VideoStreamingProtocol::RAW)); @@ -416,6 +457,33 @@ void InitCapabilities() { } // namespace +namespace { +/** + * @brief Saves smart object content into the JSON node + * @param field_name name of the field to save + * @param schema reference to schema to unapply + * @param object_to_save pointer to object to save + * @param out_json_node JSON node for the output result + */ +void save_hmi_capability_field_to_json( + const std::string& field_name, + smart_objects::CSmartSchema schema, + smart_objects::SmartObjectSPtr object_to_save, + Json::Value& out_json_node) { + if (!object_to_save) { + return; + } + namespace Formatters = ns_smart_device_link::ns_json_handler::formatters; + smart_objects::SmartObject formatted_object(smart_objects::SmartType_Map); + formatted_object[strings::msg_params][field_name] = *object_to_save; + schema.unapplySchema(formatted_object); // converts enums back to strings + Json::Value temp_value; + Formatters::CFormatterJsonBase::objToJsonValue(formatted_object, temp_value); + out_json_node[field_name] = temp_value[strings::msg_params][field_name]; +} + +} // namespace + HMICapabilitiesImpl::HMICapabilitiesImpl(ApplicationManager& app_mngr) : is_vr_cooperating_(false) , is_tts_cooperating_(false) @@ -445,10 +513,12 @@ HMICapabilitiesImpl::HMICapabilitiesImpl(ApplicationManager& app_mngr) , is_phone_call_supported_(false) , is_video_streaming_supported_(false) , is_rc_supported_(false) + , is_driver_distraction_supported_(false) , navigation_capability_(NULL) , phone_capability_(NULL) , video_streaming_capability_(NULL) , rc_capability_(NULL) + , driver_distraction_capability_(NULL) , seat_location_capability_(NULL) , app_mngr_(app_mngr) , hmi_language_handler_(app_mngr) { @@ -463,15 +533,7 @@ HMICapabilitiesImpl::HMICapabilitiesImpl(ApplicationManager& app_mngr) } } -HMICapabilitiesImpl::~HMICapabilitiesImpl() { - delete ui_supported_languages_; - delete tts_supported_languages_; - delete vr_supported_languages_; - delete navigation_capability_; - delete phone_capability_; - delete video_streaming_capability_; - delete rc_capability_; -} +HMICapabilitiesImpl::~HMICapabilitiesImpl() {} bool HMICapabilitiesImpl::VerifyImageType(const int32_t image_type) const { auto capabilities = display_capabilities(); @@ -567,27 +629,23 @@ HMICapabilitiesImpl::active_tts_language() const { void HMICapabilitiesImpl::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); + auto new_value = + std::make_shared<smart_objects::SmartObject>(supported_languages); + ui_supported_languages_.swap(new_value); } void HMICapabilitiesImpl::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); + auto new_value = + std::make_shared<smart_objects::SmartObject>(supported_languages); + tts_supported_languages_.swap(new_value); } void HMICapabilitiesImpl::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); + auto new_value = + std::make_shared<smart_objects::SmartObject>(supported_languages); + vr_supported_languages_.swap(new_value); } void HMICapabilitiesImpl::set_display_capabilities( @@ -595,7 +653,7 @@ void HMICapabilitiesImpl::set_display_capabilities( if (app_mngr_.IsSOStructValid( hmi_apis::StructIdentifiers::Common_DisplayCapabilities, display_capabilities)) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(display_capabilities); display_capabilities_.swap(new_value); } @@ -609,71 +667,69 @@ void HMICapabilitiesImpl::set_system_display_capabilities( void HMICapabilitiesImpl::set_hmi_zone_capabilities( const smart_objects::SmartObject& hmi_zone_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(hmi_zone_capabilities); hmi_zone_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_soft_button_capabilities( const smart_objects::SmartObject& soft_button_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(soft_button_capabilities); soft_buttons_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_button_capabilities( const smart_objects::SmartObject& button_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(button_capabilities); button_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_vr_capabilities( const smart_objects::SmartObject& vr_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(vr_capabilities); vr_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_speech_capabilities( const smart_objects::SmartObject& speech_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(speech_capabilities); speech_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_audio_pass_thru_capabilities( const smart_objects::SmartObject& audio_pass_thru_capabilities) { - smart_objects::SmartObjectSPtr new_value = - std::make_shared<smart_objects::SmartObject>( - audio_pass_thru_capabilities); + auto new_value = std::make_shared<smart_objects::SmartObject>( + audio_pass_thru_capabilities); audio_pass_thru_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_pcm_stream_capabilities( const smart_objects::SmartObject& pcm_stream_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(pcm_stream_capabilities); pcm_stream_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_preset_bank_capabilities( const smart_objects::SmartObject& preset_bank_capabilities) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(preset_bank_capabilities); preset_bank_capabilities_.swap(new_value); } void HMICapabilitiesImpl::set_vehicle_type( const smart_objects::SmartObject& vehicle_type) { - smart_objects::SmartObjectSPtr new_value = - std::make_shared<smart_objects::SmartObject>(vehicle_type); + auto new_value = std::make_shared<smart_objects::SmartObject>(vehicle_type); vehicle_type_.swap(new_value); } void HMICapabilitiesImpl::set_prerecorded_speech( const smart_objects::SmartObject& prerecorded_speech) { - smart_objects::SmartObjectSPtr new_value = + auto new_value = std::make_shared<smart_objects::SmartObject>(prerecorded_speech); prerecorded_speech_.swap(new_value); } @@ -693,53 +749,56 @@ void HMICapabilitiesImpl::set_rc_supported(const bool supported) { is_rc_supported_ = supported; } +void HMICapabilitiesImpl::set_driver_distraction_supported( + const bool supported) { + is_driver_distraction_supported_ = supported; +} + void HMICapabilitiesImpl::set_navigation_capability( const smart_objects::SmartObject& navigation_capability) { - if (navigation_capability_) { - delete navigation_capability_; - } - navigation_capability_ = - new smart_objects::SmartObject(navigation_capability); + auto new_value = + std::make_shared<smart_objects::SmartObject>(navigation_capability); + navigation_capability_.swap(new_value); } void HMICapabilitiesImpl::set_phone_capability( const smart_objects::SmartObject& phone_capability) { - if (phone_capability_) { - delete phone_capability_; - } - phone_capability_ = new smart_objects::SmartObject(phone_capability); + auto new_value = + std::make_shared<smart_objects::SmartObject>(phone_capability); + phone_capability_.swap(new_value); } void HMICapabilitiesImpl::set_video_streaming_capability( const smart_objects::SmartObject& video_streaming_capability) { - if (video_streaming_capability_) { - delete video_streaming_capability_; - } - video_streaming_capability_ = - new smart_objects::SmartObject(video_streaming_capability); + auto new_value = + std::make_shared<smart_objects::SmartObject>(video_streaming_capability); + video_streaming_capability_.swap(new_value); } void HMICapabilitiesImpl::set_rc_capability( const smart_objects::SmartObject& rc_capability) { - if (rc_capability_) { - delete rc_capability_; - } - rc_capability_ = new smart_objects::SmartObject(rc_capability); + auto new_value = std::make_shared<smart_objects::SmartObject>(rc_capability); + rc_capability_.swap(new_value); +} + +void HMICapabilitiesImpl::set_driver_distraction_capability( + const smart_objects::SmartObject& driver_distraction_capability) { + auto new_value = std::make_shared<smart_objects::SmartObject>( + driver_distraction_capability); + driver_distraction_capability_.swap(new_value); } void HMICapabilitiesImpl::set_seat_location_capability( const smart_objects::SmartObject& seat_location_capability) { - if (seat_location_capability_) { - delete seat_location_capability_; - } - seat_location_capability_ = - new smart_objects::SmartObject(seat_location_capability); + auto new_value = + std::make_shared<smart_objects::SmartObject>(seat_location_capability); + seat_location_capability_.swap(new_value); } void HMICapabilitiesImpl::Init( resumption::LastStateWrapperPtr last_state_wrapper) { hmi_language_handler_.Init(last_state_wrapper); - if (false == load_capabilities_from_file()) { + if (!LoadCapabilitiesFromFile()) { LOG4CXX_ERROR(logger_, "file hmi_capabilities.json was not loaded"); } else { LOG4CXX_INFO(logger_, "file hmi_capabilities.json was loaded"); @@ -774,18 +833,18 @@ bool HMICapabilitiesImpl::is_rc_cooperating() const { return is_rc_cooperating_; } -const smart_objects::SmartObject* HMICapabilitiesImpl::ui_supported_languages() - const { +const smart_objects::SmartObjectSPtr +HMICapabilitiesImpl::ui_supported_languages() const { return ui_supported_languages_; } -const smart_objects::SmartObject* HMICapabilitiesImpl::vr_supported_languages() - const { +const smart_objects::SmartObjectSPtr +HMICapabilitiesImpl::vr_supported_languages() const { return vr_supported_languages_; } -const smart_objects::SmartObject* HMICapabilitiesImpl::tts_supported_languages() - const { +const smart_objects::SmartObjectSPtr +HMICapabilitiesImpl::tts_supported_languages() const { return tts_supported_languages_; } @@ -868,33 +927,183 @@ bool HMICapabilitiesImpl::rc_supported() const { return is_rc_supported_; } -const smart_objects::SmartObject* HMICapabilitiesImpl::navigation_capability() - const { +bool HMICapabilitiesImpl::driver_distraction_supported() const { + return is_driver_distraction_supported_; +} + +const smart_objects::SmartObjectSPtr +HMICapabilitiesImpl::navigation_capability() const { return navigation_capability_; } -const smart_objects::SmartObject* HMICapabilitiesImpl::phone_capability() +const smart_objects::SmartObjectSPtr HMICapabilitiesImpl::phone_capability() const { return phone_capability_; } -const smart_objects::SmartObject* +const smart_objects::SmartObjectSPtr HMICapabilitiesImpl::video_streaming_capability() const { return video_streaming_capability_; } -const smart_objects::SmartObject* HMICapabilitiesImpl::rc_capability() const { +const smart_objects::SmartObjectSPtr HMICapabilitiesImpl::rc_capability() + const { return rc_capability_; } -const smart_objects::SmartObject* +const smart_objects::SmartObjectSPtr +HMICapabilitiesImpl::driver_distraction_capability() const { + return driver_distraction_capability_; +} + +const smart_objects::SmartObjectSPtr HMICapabilitiesImpl::seat_location_capability() const { return seat_location_capability_; } -bool HMICapabilitiesImpl::load_capabilities_from_file() { +/** + * @brief Checks if JSON member exists + * @param json_member reference to JSON structure to check + * @param name_of_member name which we should be checked + * @returns true if member exists, otherwise returns false + */ +bool JsonIsMemberSafe(const Json::Value& json_member, + const char* name_of_member) { + return !json_member.isNull() && json_member.isMember(name_of_member); +} + +/** + * @brief Converts specified string to appropriate enum value + * according to schema + * @return converted enum value + */ +template <typename EnumType> +EnumType ConvertStringToEnum(const std::string& str) { + using ns_smart_device_link::ns_smart_objects::EnumConversionHelper; + EnumType value; + if (EnumConversionHelper<EnumType>::StringToEnum(str, &value)) { + return value; + } + + return EnumType::INVALID_ENUM; +} + +/** + * @brief Converts the JSON array of string type into the SmartArray of enums + * @param json_array JSON value containing array + * @param out_so_array output SmartArray + */ +template <typename EnumType> +void ConvertJsonArrayToSoArray(const Json::Value& json_array, + smart_objects::SmartObject& out_so_array) { + out_so_array = + smart_objects::SmartObject(smart_objects::SmartType::SmartType_Array); + for (uint32_t i = 0; i < json_array.size(); ++i) { + out_so_array[i] = ConvertStringToEnum<EnumType>(json_array[i].asString()); + } +} + +/** + * @brief Helper class for obtaining proper capabilities JSON value considering + * case if it were overriden by cache + */ +struct JsonCapabilitiesGetter { + public: + /** + * @brief JsonCapabilitiesGetter constructor + * @param json_default_node reference to the main JSON capabilities node + * @param json_cache_node reference to cached JSON capabilities node + */ + JsonCapabilitiesGetter(Json::Value& json_default_node, + Json::Value& json_cache_node) + : json_default_node_(json_default_node) + , json_cache_node_(json_cache_node) {} + + JsonCapabilitiesGetter(JsonCapabilitiesGetter&& other) { + std::swap(json_default_node_, other.json_default_node_); + std::swap(json_cache_node_, other.json_cache_node_); + } + + bool IsInterfaceJsonMemberExists(const char* interface_name) { + return JsonIsMemberSafe(json_cache_node_, interface_name) || + JsonIsMemberSafe(json_default_node_, interface_name); + } + + /** + * @brief GetJsonMember gets JSON value for a specified JSON member from + * cached JSON node if member exists, otherwise main JSON node will be + * taken + * @param member_name name of the JSON member to get + * @return JSON value for specified member or Value::null if not found + */ + Json::Value GetJsonMember( + const char* member_name, + hmi_apis::FunctionID::eType request_id, + std::set<hmi_apis::FunctionID::eType>& default_initialized_capabilities) { + if (JsonIsMemberSafe(json_cache_node_, member_name)) { + return GetCachedJsonMember(member_name); + } + + LOG4CXX_DEBUG(logger_, + "Add request ID: " << request_id + << " for the interface: " << member_name); + default_initialized_capabilities.insert(request_id); + + if (JsonIsMemberSafe(json_default_node_, member_name)) { + return GetMainJsonMember(member_name); + } + + return Json::Value::null; + } + + /** + * @brief GetMainJsonMember gets JSON value for a specified JSON member from + * the main JSON node + * @param member_name name of the JSON member to get + * @return JSON value for specified member or Value::null if not found + */ + Json::Value GetMainJsonMember(const char* member_name) { + return json_default_node_.get(member_name, Json::Value::null); + } + + /** + * @brief GetCachedJsonMember gets JSON value for a specified JSON member + * from the cached JSON node + * @param member_name name of the JSON member to get + * @return JSON value for specified member or Value::null if not found + */ + Json::Value GetCachedJsonMember(const char* member_name) { + return json_cache_node_.get(member_name, Json::Value::null); + } + + private: + Json::Value json_default_node_; + Json::Value json_cache_node_; +}; + +/** + * @brief Gets the JSON node related to the specified interface name. + * @param interface_name Interface name which JSON node should be retreive from + * the main JSON node + * @return JsonCapabilitiesGetter instance initialized by default JSON node and + * cache JSON node for the specified interface + */ + +JsonCapabilitiesGetter GetInterfaceGetter( + const char* interface_name, JsonCapabilitiesGetter& json_root_getter) { + auto interface_default_node = + json_root_getter.GetMainJsonMember(interface_name); + auto interface_cache_node = + json_root_getter.GetCachedJsonMember(interface_name); + + JsonCapabilitiesGetter getter(interface_default_node, interface_cache_node); + return getter; +} + +bool HMICapabilitiesImpl::LoadCapabilitiesFromFile() { std::string json_string; - std::string file_name = app_mngr_.get_settings().hmi_capabilities_file_name(); + const std::string file_name = + app_mngr_.get_settings().hmi_capabilities_file_name(); if (!file_system::FileExists(file_name)) { return false; @@ -904,46 +1113,82 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { return false; } + const std::string cache_file_name = + app_mngr_.get_settings().hmi_capabilities_cache_file_name(); + Json::Value root_json_override; + + if (file_system::FileExists(cache_file_name)) { + LOG4CXX_DEBUG(logger_, + "HMI capabilities cache was found: " << cache_file_name); + + std::string cache_json_string; + if (!file_system::ReadFile(cache_file_name, cache_json_string)) { + LOG4CXX_DEBUG( + logger_, + "Failed to read data from cache file. Cache will be ignored"); + } + + try { + utils::JsonReader reader; + std::string json(cache_json_string.begin(), cache_json_string.end()); + if (!reader.parse(json, &root_json_override)) { + LOG4CXX_ERROR(logger_, + "Cached JSON file is invalid. Deleting the file"); + file_system::DeleteFile(cache_file_name); + root_json_override = + Json::Value::null; // Just to clear intermediate state of value + } + } catch (...) { + return false; + } + } + try { - Json::CharReaderBuilder reader_builder; - const std::unique_ptr<Json::CharReader> reader_( - reader_builder.newCharReader()); - JSONCPP_STRING err; Json::Value root_json; - const size_t json_len = json_string.length(); - - const bool result = reader_->parse( - json_string.c_str(), json_string.c_str() + json_len, &root_json, &err); - if (!result) { - LOG4CXX_DEBUG(logger_, "Json parsing fails: " << err); + utils::JsonReader reader; + std::string json(json_string.begin(), json_string.end()); + if (!reader.parse(json, &root_json)) { + LOG4CXX_DEBUG(logger_, "Default JSON parsing fails"); return false; } + + JsonCapabilitiesGetter json_root_getter(root_json, root_json_override); // UI - if (check_existing_json_member(root_json, "UI")) { - Json::Value ui = root_json.get("UI", Json::Value::null); + if (json_root_getter.IsInterfaceJsonMemberExists(hmi_interface::ui)) { + auto json_ui_getter = + GetInterfaceGetter(hmi_interface::ui, json_root_getter); - if (check_existing_json_member(ui, "language")) { - const std::string lang = ui.get("language", "EN-US").asString(); + auto ui_language_node = + json_ui_getter.GetJsonMember(hmi_response::language, + hmi_apis::FunctionID::UI_GetLanguage, + requests_required_for_capabilities_); + + if (!ui_language_node.isNull()) { + const std::string lang = ui_language_node.asString(); set_active_ui_language( StringToEnum<hmi_apis::Common_Language::eType>(lang)); - } else { - set_active_ui_language( - StringToEnum<hmi_apis::Common_Language::eType>("EN-US")); } - if (check_existing_json_member(ui, "languages")) { + auto ui_languages_node = json_ui_getter.GetJsonMember( + hmi_response::languages, + hmi_apis::FunctionID::UI_GetSupportedLanguages, + requests_required_for_capabilities_); + if (!ui_languages_node.isNull()) { 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); + ConvertJsonArrayToSoArray<hmi_apis::Common_Language::eType>( + ui_languages_node, ui_languages_so); set_ui_supported_languages(ui_languages_so); } - if (check_existing_json_member(ui, "displayCapabilities")) { + auto ui_display_capabilities_node = + json_ui_getter.GetJsonMember(hmi_response::display_capabilities, + hmi_apis::FunctionID::UI_GetCapabilities, + requests_required_for_capabilities_); + if (!ui_display_capabilities_node.isNull()) { smart_objects::SmartObject display_capabilities_so; - Json::Value display_capabilities = ui.get("displayCapabilities", ""); - formatters::CFormatterJsonBase::jsonValueToObj(display_capabilities, - display_capabilities_so); + formatters::CFormatterJsonBase::jsonValueToObj( + ui_display_capabilities_node, display_capabilities_so); if (display_capabilities_so.keyExists(hmi_response::display_type)) { std::map<std::string, @@ -1077,55 +1322,73 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { set_display_capabilities(display_capabilities_so); } - if (check_existing_json_member(ui, "audioPassThruCapabilities")) { - Json::Value audio_capabilities = - ui.get("audioPassThruCapabilities", ""); + auto ui_audio_pass_thru_capabilities_node = + json_ui_getter.GetJsonMember(strings::audio_pass_thru_capabilities, + hmi_apis::FunctionID::UI_GetCapabilities, + requests_required_for_capabilities_); + if (!ui_audio_pass_thru_capabilities_node.isNull()) { smart_objects::SmartObject audio_capabilities_so( smart_objects::SmartType_Array); - if (audio_capabilities.type() == Json::arrayValue) { - for (uint32_t i = 0; i < audio_capabilities.size(); i++) { - convert_audio_capability_to_obj(audio_capabilities[i], - audio_capabilities_so[i]); + if (ui_audio_pass_thru_capabilities_node.type() == Json::arrayValue) { + for (uint32_t i = 0; i < ui_audio_pass_thru_capabilities_node.size(); + i++) { + convert_audio_capability_to_obj( + ui_audio_pass_thru_capabilities_node[i], + audio_capabilities_so[i]); } - } else if (audio_capabilities.type() == Json::objectValue) { - convert_audio_capability_to_obj(audio_capabilities, + } else if (ui_audio_pass_thru_capabilities_node.type() == + Json::objectValue) { + convert_audio_capability_to_obj(ui_audio_pass_thru_capabilities_node, audio_capabilities_so[0]); } set_audio_pass_thru_capabilities(audio_capabilities_so); } - if (check_existing_json_member(ui, "pcmStreamCapabilities")) { - Json::Value pcm_capabilities = ui.get("pcmStreamCapabilities", ""); + auto ui_pcm_stream_capabilities_node = + json_ui_getter.GetJsonMember(strings::pcm_stream_capabilities, + hmi_apis::FunctionID::UI_GetCapabilities, + requests_required_for_capabilities_); + if (!ui_pcm_stream_capabilities_node.isNull()) { smart_objects::SmartObject pcm_capabilities_so = smart_objects::SmartObject(smart_objects::SmartType_Map); - convert_audio_capability_to_obj(pcm_capabilities, pcm_capabilities_so); + convert_audio_capability_to_obj(ui_pcm_stream_capabilities_node, + pcm_capabilities_so); set_pcm_stream_capabilities(pcm_capabilities_so); } - if (check_existing_json_member(ui, "hmiZoneCapabilities")) { + auto ui_hmi_zone_capabilities_node = + json_ui_getter.GetJsonMember(hmi_response::hmi_zone_capabilities, + hmi_apis::FunctionID::UI_GetCapabilities, + requests_required_for_capabilities_); + if (!ui_hmi_zone_capabilities_node.isNull()) { smart_objects::SmartObject hmi_zone_capabilities_so = smart_objects::SmartObject(smart_objects::SmartType_Array); hmi_zone_capabilities_so = - hmi_zone_enum.find(ui.get("hmiZoneCapabilities", "").asString()) + hmi_zone_enum.find(ui_hmi_zone_capabilities_node.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", ""); + auto ui_soft_button_capabilities_node = + json_ui_getter.GetJsonMember(hmi_response::soft_button_capabilities, + hmi_apis::FunctionID::UI_GetCapabilities, + requests_required_for_capabilities_); + if (!ui_soft_button_capabilities_node.isNull()) { smart_objects::SmartObject soft_button_capabilities_so; formatters::CFormatterJsonBase::jsonValueToObj( - soft_button_capabilities, soft_button_capabilities_so); + ui_soft_button_capabilities_node, soft_button_capabilities_so); set_soft_button_capabilities(soft_button_capabilities_so); } - if (check_existing_json_member(ui, "systemCapabilities")) { - Json::Value system_capabilities = ui.get("systemCapabilities", ""); - if (check_existing_json_member(system_capabilities, - "navigationCapability")) { - Json::Value navigation_capability = - system_capabilities.get("navigationCapability", ""); + auto ui_system_capabilities_node = + json_ui_getter.GetJsonMember(strings::system_capabilities, + hmi_apis::FunctionID::UI_GetCapabilities, + requests_required_for_capabilities_); + if (!ui_system_capabilities_node.isNull()) { + if (JsonIsMemberSafe(ui_system_capabilities_node, + strings::navigation_capability)) { + Json::Value navigation_capability = ui_system_capabilities_node.get( + strings::navigation_capability, ""); smart_objects::SmartObject navigation_capability_so; formatters::CFormatterJsonBase::jsonValueToObj( navigation_capability, navigation_capability_so); @@ -1134,10 +1397,10 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { set_navigation_supported(true); } } - if (check_existing_json_member(system_capabilities, - "phoneCapability")) { + if (JsonIsMemberSafe(ui_system_capabilities_node, + strings::phone_capability)) { Json::Value phone_capability = - system_capabilities.get("phoneCapability", ""); + ui_system_capabilities_node.get(strings::phone_capability, ""); smart_objects::SmartObject phone_capability_so; formatters::CFormatterJsonBase::jsonValueToObj(phone_capability, phone_capability_so); @@ -1146,23 +1409,23 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { set_phone_call_supported(true); } } - if (check_existing_json_member(system_capabilities, - "videoStreamingCapability")) { - Json::Value vs_capability = - system_capabilities.get("videoStreamingCapability", ""); + if (JsonIsMemberSafe(ui_system_capabilities_node, + strings::video_streaming_capability)) { + Json::Value vs_capability = ui_system_capabilities_node.get( + strings::video_streaming_capability, ""); smart_objects::SmartObject vs_capability_so; formatters::CFormatterJsonBase::jsonValueToObj(vs_capability, vs_capability_so); - if (vs_capability_so.keyExists("supportedFormats")) { + if (vs_capability_so.keyExists(strings::supported_formats)) { smart_objects::SmartObject& supported_format_array = - vs_capability_so["supportedFormats"]; + vs_capability_so[strings::supported_formats]; smart_objects::SmartObject converted_array( smart_objects::SmartType_Array); for (uint32_t i = 0, j = 0; i < supported_format_array.length(); i++) { - if (!supported_format_array[i].keyExists("protocol") || - !supported_format_array[i].keyExists("codec")) { + if (!supported_format_array[i].keyExists(strings::protocol) || + !supported_format_array[i].keyExists(strings::codec)) { continue; } @@ -1170,12 +1433,13 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { hmi_apis::Common_VideoStreamingProtocol::eType>:: const_iterator it_protocol = video_streaming_protocol_enum.find( - supported_format_array[i]["protocol"].asString()); + supported_format_array[i][strings::protocol] + .asString()); std::map<std::string, hmi_apis::Common_VideoStreamingCodec::eType>:: const_iterator it_codec = video_streaming_codec_enum.find( - supported_format_array[i]["codec"].asString()); + supported_format_array[i][strings::codec].asString()); // format is valid only if both protocol and codec are converted // to enum values successfully @@ -1183,131 +1447,203 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { it_codec != video_streaming_codec_enum.end()) { smart_objects::SmartObject format_so = smart_objects::SmartObject(smart_objects::SmartType_Map); - format_so["protocol"] = it_protocol->second; - format_so["codec"] = it_codec->second; + format_so[strings::protocol] = it_protocol->second; + format_so[strings::codec] = it_codec->second; converted_array[j++] = format_so; } } - vs_capability_so.erase("supportedFormats"); - vs_capability_so["supportedFormats"] = converted_array; + vs_capability_so.erase(strings::supported_formats); + vs_capability_so[strings::supported_formats] = converted_array; } set_video_streaming_capability(vs_capability_so); if (!vs_capability_so.empty()) { set_video_streaming_supported(true); } } - if (check_existing_json_member(system_capabilities, - "remoteControlCapability")) { - Json::Value rc_capability = - system_capabilities.get("remoteControlCapability", ""); - smart_objects::SmartObject rc_capability_so; - formatters::CFormatterJsonBase::jsonValueToObj(rc_capability, - rc_capability_so); - if (rc_capability_so.keyExists("lightControlCapabilities")) { - if (rc_capability_so["lightControlCapabilities"].keyExists( - "supportedLights")) { - auto& lights = rc_capability_so["lightControlCapabilities"] - ["supportedLights"]; - auto it = lights.asArray()->begin(); - for (; it != lights.asArray()->end(); ++it) { - smart_objects::SmartObject& light_name_so = (*it)["name"]; - auto light_name = - StringToEnum<hmi_apis::Common_LightName::eType>( - light_name_so.asString()); - light_name_so = light_name; - } + + if (JsonIsMemberSafe(ui_system_capabilities_node, + strings::driver_distraction_capability)) { + Json::Value dd_capability = ui_system_capabilities_node.get( + strings::driver_distraction_capability, ""); + smart_objects::SmartObject dd_capability_so; + formatters::CFormatterJsonBase::jsonValueToObj(dd_capability, + dd_capability_so); + set_driver_distraction_capability(dd_capability_so); + if (!dd_capability_so.empty()) { + set_driver_distraction_supported(true); + } + } + } + } else { + AddRequiredRequestsForCapabilities(hmi_interface::ui); + } // UI end + + // RC + if (json_root_getter.IsInterfaceJsonMemberExists(hmi_interface::rc)) { + auto rc_json_getter = + GetInterfaceGetter(hmi_interface::rc, json_root_getter); + + auto rc_capabilitity_node = + rc_json_getter.GetJsonMember(strings::rc_capability, + hmi_apis::FunctionID::RC_GetCapabilities, + requests_required_for_capabilities_); + if (!rc_capabilitity_node.isNull()) { + smart_objects::SmartObject rc_capability_so; + formatters::CFormatterJsonBase::jsonValueToObj(rc_capabilitity_node, + rc_capability_so); + if (rc_capability_so.keyExists( + rc_rpc_plugin::strings::klightControlCapabilities)) { + if (rc_capability_so + [rc_rpc_plugin::strings::klightControlCapabilities] + .keyExists(rc_rpc_plugin::strings::kSupportedLights)) { + auto& lights = rc_capability_so + [rc_rpc_plugin::strings::klightControlCapabilities] + [rc_rpc_plugin::strings::kSupportedLights]; + auto it = lights.asArray()->begin(); + for (; it != lights.asArray()->end(); ++it) { + smart_objects::SmartObject& light_name_so = (*it)[strings::name]; + auto light_name = StringToEnum<hmi_apis::Common_LightName::eType>( + light_name_so.asString()); + light_name_so = light_name; } } + } + if (!rc_capability_so.empty()) { + set_rc_supported(true); set_rc_capability(rc_capability_so); - if (!rc_capability_so.empty()) { - set_rc_supported(true); - } } - if (check_existing_json_member(system_capabilities, - "seatLocationCapability")) { - Json::Value seat_location_capability = - system_capabilities.get("seatLocationCapability", ""); - smart_objects::SmartObject seat_location_capability_so; - formatters::CFormatterJsonBase::jsonValueToObj( - seat_location_capability, seat_location_capability_so); + } + + auto seat_location_capabilitiy_node = + rc_json_getter.GetJsonMember(strings::seat_location_capability, + hmi_apis::FunctionID::RC_GetCapabilities, + requests_required_for_capabilities_); + + if (!seat_location_capabilitiy_node.isNull()) { + smart_objects::SmartObject seat_location_capability_so; + formatters::CFormatterJsonBase::jsonValueToObj( + seat_location_capabilitiy_node, seat_location_capability_so); + + if (!seat_location_capability_so.empty()) { + set_rc_supported(true); set_seat_location_capability(seat_location_capability_so); } } - } // UI end + } else { + AddRequiredRequestsForCapabilities(hmi_interface::rc); + } + // RC end // VR - if (check_existing_json_member(root_json, "VR")) { - Json::Value vr = root_json.get("VR", ""); - if (check_existing_json_member(vr, "language")) { - const std::string lang = vr.get("language", "EN-US").asString(); + if (json_root_getter.IsInterfaceJsonMemberExists(hmi_interface::vr)) { + auto json_vr_getter = + GetInterfaceGetter(hmi_interface::vr, json_root_getter); + + auto vr_language_node = + json_vr_getter.GetJsonMember(hmi_response::language, + hmi_apis::FunctionID::VR_GetLanguage, + requests_required_for_capabilities_); + if (!vr_language_node.isNull()) { + const std::string lang = vr_language_node.asString(); set_active_vr_language( StringToEnum<hmi_apis::Common_Language::eType>(lang)); - } else { - set_active_vr_language( - StringToEnum<hmi_apis::Common_Language::eType>("EN-US")); } - if (check_existing_json_member(vr, "languages")) { - Json::Value languages_vr = vr.get("languages", ""); + auto vr_languages_node = json_vr_getter.GetJsonMember( + hmi_response::languages, + hmi_apis::FunctionID::VR_GetSupportedLanguages, + requests_required_for_capabilities_); + if (!vr_languages_node.isNull()) { smart_objects::SmartObject vr_languages_so = smart_objects::SmartObject(smart_objects::SmartType_Array); - convert_json_languages_to_obj(languages_vr, vr_languages_so); + ConvertJsonArrayToSoArray<hmi_apis::Common_Language::eType>( + vr_languages_node, vr_languages_so); set_vr_supported_languages(vr_languages_so); } - if (check_existing_json_member(vr, "capabilities")) { - Json::Value capabilities = vr.get("capabilities", ""); + auto vr_capabilities_node = + json_vr_getter.GetJsonMember(strings::vr_capabilities, + hmi_apis::FunctionID::VR_GetCapabilities, + requests_required_for_capabilities_); + if (!vr_capabilities_node.isNull()) { 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; - } + ConvertJsonArrayToSoArray<hmi_apis::Common_VrCapabilities::eType>( + vr_capabilities_node, vr_capabilities_so); set_vr_capabilities(vr_capabilities_so); } + } else { + AddRequiredRequestsForCapabilities(hmi_interface::vr); } // 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")) { - const std::string lang = tts.get("language", "EN-US").asString(); + if (json_root_getter.IsInterfaceJsonMemberExists(hmi_interface::tts)) { + auto json_tts_getter = + GetInterfaceGetter(hmi_interface::tts, json_root_getter); + + auto tts_language_node = + json_tts_getter.GetJsonMember(hmi_response::language, + hmi_apis::FunctionID::TTS_GetLanguage, + requests_required_for_capabilities_); + if (!tts_language_node.isNull()) { + const std::string lang = tts_language_node.asString(); set_active_tts_language( StringToEnum<hmi_apis::Common_Language::eType>(lang)); - } else { - set_active_tts_language( - StringToEnum<hmi_apis::Common_Language::eType>("EN-US")); } - if (check_existing_json_member(tts, "languages")) { - Json::Value languages_tts = tts.get("languages", ""); + auto tts_languages_node = json_tts_getter.GetJsonMember( + hmi_response::languages, + hmi_apis::FunctionID::TTS_GetSupportedLanguages, + requests_required_for_capabilities_); + if (!tts_languages_node.isNull()) { smart_objects::SmartObject tts_languages_so = smart_objects::SmartObject(smart_objects::SmartType_Array); - convert_json_languages_to_obj(languages_tts, tts_languages_so); + ConvertJsonArrayToSoArray<hmi_apis::Common_Language::eType>( + tts_languages_node, tts_languages_so); set_tts_supported_languages(tts_languages_so); } - if (check_existing_json_member(tts, "capabilities")) { - Json::Value capabilities = tts.get("capabilities", ""); + auto tts_speech_capabilities_node = json_tts_getter.GetJsonMember( + hmi_response::speech_capabilities, + hmi_apis::FunctionID::TTS_GetCapabilities, + requests_required_for_capabilities_); + if (!tts_speech_capabilities_node.isNull()) { smart_objects::SmartObject tts_capabilities_so = smart_objects::SmartObject(smart_objects::SmartType_Array); - for (uint32_t i = 0; i < capabilities.size(); ++i) { - tts_capabilities_so[i] = - tts_enum_capabilities.find(capabilities[i].asString())->second; - } + ConvertJsonArrayToSoArray<hmi_apis::Common_SpeechCapabilities::eType>( + tts_speech_capabilities_node, tts_capabilities_so); set_speech_capabilities(tts_capabilities_so); } + + auto tts_prerecorded_speech_capabilities_node = + json_tts_getter.GetJsonMember( + hmi_response::prerecorded_speech_capabilities, + hmi_apis::FunctionID::TTS_GetCapabilities, + requests_required_for_capabilities_); + if (!tts_prerecorded_speech_capabilities_node.isNull()) { + smart_objects::SmartObject tts_capabilities_so = + smart_objects::SmartObject(smart_objects::SmartType_Array); + ConvertJsonArrayToSoArray<hmi_apis::Common_PrerecordedSpeech::eType>( + tts_prerecorded_speech_capabilities_node, tts_capabilities_so); + set_prerecorded_speech(tts_capabilities_so); + } + } else { + AddRequiredRequestsForCapabilities(hmi_interface::tts); } // 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", ""); + if (json_root_getter.IsInterfaceJsonMemberExists(hmi_interface::buttons)) { + auto json_buttons_getter = + GetInterfaceGetter(hmi_interface::buttons, json_root_getter); + + auto buttons_capabilities_node = json_buttons_getter.GetJsonMember( + hmi_response::capabilities, + hmi_apis::FunctionID::Buttons_GetCapabilities, + requests_required_for_capabilities_); + if (!buttons_capabilities_node.isNull()) { smart_objects::SmartObject buttons_capabilities_so; - formatters::CFormatterJsonBase::jsonValueToObj(bt_capabilities, - buttons_capabilities_so); + formatters::CFormatterJsonBase::jsonValueToObj( + buttons_capabilities_node, buttons_capabilities_so); for (uint32_t i = 0; i < buttons_capabilities_so.length(); ++i) { if ((buttons_capabilities_so[i]).keyExists(strings::name)) { @@ -1323,27 +1659,572 @@ bool HMICapabilitiesImpl::load_capabilities_from_file() { } set_button_capabilities(buttons_capabilities_so); } - if (check_existing_json_member(buttons, "presetBankCapabilities")) { - Json::Value presetBank = buttons.get("presetBankCapabilities", ""); + + auto buttons_preset_bank_capabilities_node = + json_buttons_getter.GetMainJsonMember( + hmi_response::preset_bank_capabilities); + if (!buttons_preset_bank_capabilities_node.isNull()) { smart_objects::SmartObject preset_bank_so; - formatters::CFormatterJsonBase::jsonValueToObj(presetBank, - preset_bank_so); + formatters::CFormatterJsonBase::jsonValueToObj( + buttons_preset_bank_capabilities_node, preset_bank_so); set_preset_bank_capabilities(preset_bank_so); } + } else { + AddRequiredRequestsForCapabilities(hmi_interface::buttons); } // 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); + + if (json_root_getter.IsInterfaceJsonMemberExists( + hmi_interface::vehicle_info)) { + auto json_vehicle_info_getter = + GetInterfaceGetter(hmi_interface::vehicle_info, json_root_getter); + + auto vehicle_type_node = json_vehicle_info_getter.GetJsonMember( + hmi_response::vehicle_type, + hmi_apis::FunctionID::VehicleInfo_GetVehicleType, + requests_required_for_capabilities_); + if (!vehicle_type_node.isNull()) { + smart_objects::SmartObject vehicle_type_so; + formatters::CFormatterJsonBase::jsonValueToObj(vehicle_type_node, + vehicle_type_so); + set_vehicle_type(vehicle_type_so); + } + } else { + AddRequiredRequestsForCapabilities(hmi_interface::vehicle_info); } // VehicleType end } catch (...) { return false; } return true; +} // namespace application_manager + +hmi_apis::Common_Language::eType +HMICapabilitiesImpl::GetActiveLanguageForInterface( + const std::string& interface_name) const { + LOG4CXX_AUTO_TRACE(logger_); + if (hmi_interface::ui == interface_name) { + return active_ui_language(); + } + if (hmi_interface::vr == interface_name) { + return active_vr_language(); + } + if (hmi_interface::tts == interface_name) { + return active_tts_language(); + } + return hmi_apis::Common_Language::INVALID_ENUM; +} + +void HMICapabilitiesImpl::UpdateRequestsRequiredForCapabilities( + hmi_apis::FunctionID::eType requested_interface) { + LOG4CXX_AUTO_TRACE(logger_); + if (app_mngr_.IsHMICooperating()) { + LOG4CXX_DEBUG(logger_, + "Remove from default initialized capabilities skipped, " + "because hmi_cooperating equal true already"); + return; + } + + RemoveFromRequestsRequiredForCapabilities(requested_interface); + if (requests_required_for_capabilities_.empty()) { + app_mngr_.SetHMICooperating(true); + } +} + +void HMICapabilitiesImpl::OnSoftwareVersionReceived( + const std::string& ccpu_version) { + LOG4CXX_AUTO_TRACE(logger_); + + if (ccpu_version == ccpu_version_) { + LOG4CXX_DEBUG(logger_, "Software version not changed"); + if (requests_required_for_capabilities_.empty()) { + app_mngr_.SetHMICooperating(true); + } + app_mngr_.RequestForInterfacesAvailability(); + return; + } + + LOG4CXX_DEBUG(logger_, "Software version changed"); + set_ccpu_version(ccpu_version); + UpdateCachedCapabilities(); +} + +void HMICapabilitiesImpl::UpdateCachedCapabilities() { + LOG4CXX_AUTO_TRACE(logger_); + + DeleteCachedCapabilitiesFile(); + + if (!LoadCapabilitiesFromFile()) { + LOG4CXX_ERROR(logger_, "file hmi_capabilities.json was not loaded"); + } + + app_mngr_.RequestForInterfacesAvailability(); +} + +bool HMICapabilitiesImpl::AllFieldsSaved( + const Json::Value& root_node, + const std::string& interface_name, + const std::vector<std::string>& sections_to_check) const { + LOG4CXX_AUTO_TRACE(logger_); + if (!JsonIsMemberSafe(root_node, interface_name.c_str())) { + LOG4CXX_DEBUG(logger_, + interface_name + << " interface is not found. All fields should be saved"); + return false; + } + + const auto& interface_node = root_node.get(interface_name, Json::Value::null); + for (auto it = sections_to_check.begin(); it != sections_to_check.end(); + ++it) { + const std::string section = (*it).c_str(); + if (!JsonIsMemberSafe(interface_node, section.c_str())) { + LOG4CXX_DEBUG(logger_, + "Field " << *it << " should be saved into the file"); + return false; + } + + if (hmi_response::language == section) { + const auto active_language = + GetActiveLanguageForInterface(interface_name); + const auto json_language = interface_node[hmi_response::language]; + + if (active_language != + MessageHelper::CommonLanguageFromString(json_language.asString())) { + LOG4CXX_DEBUG(logger_, + "Active " << interface_name + << " language is not the same as the persisted " + "one. Field should be overwritten"); + return false; + } + } + } + + return true; +} + +void HMICapabilitiesImpl::RemoveFromRequestsRequiredForCapabilities( + hmi_apis::FunctionID::eType requested_interface) { + LOG4CXX_AUTO_TRACE(logger_); + + auto it = find(requests_required_for_capabilities_.begin(), + requests_required_for_capabilities_.end(), + requested_interface); + if (it != requests_required_for_capabilities_.end()) { + requests_required_for_capabilities_.erase(it); + LOG4CXX_DEBUG(logger_, + "Wait for " << requests_required_for_capabilities_.size() + << " responses"); + } +} + +void HMICapabilitiesImpl::PrepareUiJsonValueForSaving( + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_node) const { + LOG4CXX_AUTO_TRACE(logger_); + + smart_objects::SmartObject capability(smart_objects::SmartType_Map); + auto system_capabilities = std::make_shared<smart_objects::SmartObject>( + capability[strings::system_capabilities]); + + for (const auto& section_to_update : sections_to_update) { + if (section_to_update == hmi_response::hmi_zone_capabilities) { + save_hmi_capability_field_to_json(hmi_response::hmi_zone_capabilities, + schema, + hmi_zone_capabilities(), + out_node); + } + + else if (section_to_update == hmi_response::soft_button_capabilities) { + save_hmi_capability_field_to_json(hmi_response::soft_button_capabilities, + schema, + soft_button_capabilities(), + out_node); + } + + else if (section_to_update == strings::audio_pass_thru_capabilities) { + smart_objects::SmartObjectSPtr audio_pass_thru_capabilities_so = + audio_pass_thru_capabilities(); + + for (size_t i = 0; i < audio_pass_thru_capabilities_so->length(); ++i) { + const smart_objects::SmartObject& element = + (*audio_pass_thru_capabilities_so)[i]; + const auto audio_pass_thru_capabilities = + std::make_shared<smart_objects::SmartObject>(element); + Json::Value out_audio_pass_thru; + save_hmi_capability_field_to_json(strings::audio_pass_thru_capabilities, + schema, + audio_pass_thru_capabilities, + out_audio_pass_thru); + out_node[strings::audio_pass_thru_capabilities][Json::ArrayIndex(i)] = + out_audio_pass_thru[strings::audio_pass_thru_capabilities]; + } + } + + else if (section_to_update == strings::navigation) { + out_node[strings::hmi_capabilities][strings::navigation] = + navigation_supported(); + } + + else if (section_to_update == strings::phone_call) { + out_node[strings::hmi_capabilities][strings::phone_call] = + phone_call_supported(); + } + + else if (section_to_update == strings::video_streaming) { + out_node[strings::hmi_capabilities][strings::video_streaming] = + video_streaming_supported(); + } + + else if (section_to_update == strings::navigation_capability) { + const auto navigation_capability_so = navigation_capability(); + if (navigation_capability_so) { + (*system_capabilities)[strings::navigation_capability] = + *navigation_capability_so; + } + } + + else if (section_to_update == strings::phone_capability) { + const auto phone_capability_so = phone_capability(); + if (phone_capability_so) { + (*system_capabilities)[strings::phone_capability] = + *phone_capability_so; + } + } + + else if (section_to_update == strings::video_streaming_capability) { + const auto video_streaming_capability_so = video_streaming_capability(); + + if (video_streaming_capability_so) { + (*system_capabilities)[strings::video_streaming_capability] = + *video_streaming_capability_so; + } + } + + else if (section_to_update == strings::display_capabilities) { + const auto display_capabilities_so = display_capabilities(); + + if (display_capabilities_so) { + save_hmi_capability_field_to_json(strings::display_capabilities, + schema, + display_capabilities_so, + out_node); + } + } + + else if (section_to_update == strings::pcm_stream_capabilities) { + save_hmi_capability_field_to_json(strings::pcm_stream_capabilities, + schema, + pcm_stream_capabilities(), + out_node); + } + + else if (section_to_update == hmi_response::language) { + out_node[hmi_response::language] = + MessageHelper::CommonLanguageToString(active_ui_language()); + } + + else if (section_to_update == hmi_response::languages) { + save_hmi_capability_field_to_json( + hmi_response::languages, schema, ui_supported_languages(), out_node); + } + } + + if (!system_capabilities->empty()) { + save_hmi_capability_field_to_json( + strings::system_capabilities, schema, system_capabilities, out_node); + } +} + +void HMICapabilitiesImpl::PrepareVrJsonValueForSaving( + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_node) const { + LOG4CXX_AUTO_TRACE(logger_); + + for (const auto& section_to_update : sections_to_update) { + if (section_to_update == hmi_response::language) { + out_node[hmi_response::language] = + MessageHelper::CommonLanguageToString(active_vr_language()); + } + + if (section_to_update == hmi_response::languages) { + save_hmi_capability_field_to_json( + hmi_response::languages, schema, vr_supported_languages(), out_node); + } + + if (section_to_update == strings::vr_capabilities) { + save_hmi_capability_field_to_json( + strings::vr_capabilities, schema, vr_capabilities(), out_node); + } + } +} + +void HMICapabilitiesImpl::PrepareTtsJsonValueForSaving( + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_node) const { + LOG4CXX_AUTO_TRACE(logger_); + + for (const auto& section_to_update : sections_to_update) { + if (section_to_update == hmi_response::language) { + out_node[hmi_response::language] = + MessageHelper::CommonLanguageToString(active_tts_language()); + } + + if (section_to_update == hmi_response::languages) { + save_hmi_capability_field_to_json( + hmi_response::languages, schema, tts_supported_languages(), out_node); + } + + if (section_to_update == hmi_response::speech_capabilities) { + save_hmi_capability_field_to_json(hmi_response::speech_capabilities, + schema, + speech_capabilities(), + out_node); + } + + if (section_to_update == hmi_response::prerecorded_speech_capabilities) { + save_hmi_capability_field_to_json( + hmi_response::prerecorded_speech_capabilities, + schema, + prerecorded_speech(), + out_node); + } + } +} + +void HMICapabilitiesImpl::PrepareButtonsJsonValueForSaving( + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_node) const { + LOG4CXX_AUTO_TRACE(logger_); + + for (const auto& section_to_update : sections_to_update) { + if (section_to_update == hmi_response::button_capabilities) { + save_hmi_capability_field_to_json( + hmi_response::capabilities, schema, button_capabilities(), out_node); + } + + if (section_to_update == hmi_response::preset_bank_capabilities) { + save_hmi_capability_field_to_json(hmi_response::preset_bank_capabilities, + schema, + preset_bank_capabilities(), + out_node); + } + } +} + +void HMICapabilitiesImpl::PrepareVehicleInfoJsonValueForSaving( + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_node) const { + LOG4CXX_AUTO_TRACE(logger_); + if (helpers::in_range(sections_to_update, hmi_response::vehicle_type)) { + save_hmi_capability_field_to_json( + hmi_response::vehicle_type, schema, vehicle_type(), out_node); + } +} + +void HMICapabilitiesImpl::PrepareRCJsonValueForSaving( + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_node) const { + LOG4CXX_AUTO_TRACE(logger_); + + for (const auto& section_to_update : sections_to_update) { + if (section_to_update == strings::rc_capability) { + save_hmi_capability_field_to_json( + strings::rc_capability, schema, rc_capability(), out_node); + } + + if (section_to_update == strings::seat_location_capability) { + save_hmi_capability_field_to_json(strings::seat_location_capability, + schema, + seat_location_capability(), + out_node); + } + } +} + +void HMICapabilitiesImpl::AddRequiredRequestsForCapabilities( + const std::string& interface_name) { + LOG4CXX_DEBUG(logger_, "Add request IDs for interface: " << interface_name); + + if (interface_name == hmi_interface::ui) { + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::UI_GetLanguage); + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::UI_GetSupportedLanguages); + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::UI_GetCapabilities); + } + + else if (interface_name == hmi_interface::rc) { + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::RC_GetCapabilities); + } + + else if (interface_name == hmi_interface::vr) { + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::VR_GetLanguage); + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::VR_GetSupportedLanguages); + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::VR_GetCapabilities); + } + + else if (interface_name == hmi_interface::tts) { + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::TTS_GetLanguage); + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::TTS_GetSupportedLanguages); + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::TTS_GetCapabilities); + } + + else if (interface_name == hmi_interface::buttons) { + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::Buttons_GetCapabilities); + } + + else if (interface_name == hmi_interface::vehicle_info) { + requests_required_for_capabilities_.insert( + hmi_apis::FunctionID::VehicleInfo_GetVehicleType); + } +} + +void HMICapabilitiesImpl::PrepareJsonValueForSaving( + const char* interface_name, + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema, + Json::Value& out_root_node) const { + LOG4CXX_DEBUG(logger_, + "Prepare " << interface_name << " sections for saving"); + + if (out_root_node.isNull()) { + out_root_node = Json::Value(Json::objectValue); + } + + if (!out_root_node.isMember(interface_name)) { + out_root_node[interface_name] = Json::Value(Json::objectValue); + } + + Json::Value& interface_node = out_root_node[interface_name]; + if (strcmp(interface_name, hmi_interface::ui) == 0) { + PrepareUiJsonValueForSaving(sections_to_update, schema, interface_node); + } + + else if (strcmp(interface_name, hmi_interface::vr) == 0) { + PrepareVrJsonValueForSaving(sections_to_update, schema, interface_node); + } + + else if (strcmp(interface_name, hmi_interface::tts) == 0) { + PrepareTtsJsonValueForSaving(sections_to_update, schema, interface_node); + } + + else if (strcmp(interface_name, hmi_interface::buttons) == 0) { + PrepareButtonsJsonValueForSaving( + sections_to_update, schema, interface_node); + } + + else if (strcmp(interface_name, hmi_interface::vehicle_info) == 0) { + PrepareVehicleInfoJsonValueForSaving( + sections_to_update, schema, interface_node); + } + + else if (strcmp(interface_name, hmi_interface::rc) == 0) { + PrepareRCJsonValueForSaving(sections_to_update, schema, interface_node); + } +} + +bool HMICapabilitiesImpl::SaveCachedCapabilitiesToFile( + const std::string& interface_name, + const std::vector<std::string>& sections_to_update, + const smart_objects::CSmartSchema& schema) { + LOG4CXX_AUTO_TRACE(logger_); + + if (sections_to_update.empty()) { + LOG4CXX_DEBUG(logger_, + "There is no one section to update in the cache file"); + return true; + } + + const std::string cache_file_name = + app_mngr_.get_settings().hmi_capabilities_cache_file_name(); + if (cache_file_name.empty()) { + LOG4CXX_DEBUG(logger_, + "Cache file name is not specified. No need to save cache"); + return true; + } + + Json::Value root_node; + if (file_system::FileExists(cache_file_name)) { + LOG4CXX_DEBUG(logger_, "Cache file exists. Check for it's content"); + + std::string file_content; + if (!file_system::ReadFile(cache_file_name, file_content)) { + LOG4CXX_ERROR(logger_, "Failed to read file content"); + return false; + } + + Json::CharReaderBuilder builder; + const std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); + if (!reader->parse(file_content.c_str(), + file_content.c_str() + file_content.length(), + &root_node, + NULL)) { + LOG4CXX_ERROR(logger_, "Can't parse the file. Skipping"); + return false; + } + + if (AllFieldsSaved(root_node, interface_name, sections_to_update)) { + LOG4CXX_DEBUG( + logger_, + "All " << interface_name + << " fields are present in the file. No need to update"); + return true; + } + + LOG4CXX_DEBUG(logger_, "Some fields in the cache file should be updated"); + } + + PrepareJsonValueForSaving( + interface_name.c_str(), sections_to_update, schema, root_node); + + LOG4CXX_DEBUG(logger_, "Saving cache to file: " << cache_file_name); + const std::string content_to_save = root_node.toStyledString(); + const std::vector<uint8_t> binary_data_to_save(content_to_save.begin(), + content_to_save.end()); + + return file_system::Write(cache_file_name, binary_data_to_save); +} + +bool HMICapabilitiesImpl::DeleteCachedCapabilitiesFile() const { + LOG4CXX_AUTO_TRACE(logger_); + const std::string cache_file_name = + app_mngr_.get_settings().hmi_capabilities_cache_file_name(); + if (cache_file_name.empty()) { + LOG4CXX_DEBUG(logger_, + "Cache file name is not specified. Nothing to delete"); + return false; + } + + if (!file_system::FileExists(cache_file_name)) { + LOG4CXX_DEBUG(logger_, "Cache file does not exist"); + return false; + } + + if (!file_system::DeleteFile(cache_file_name)) { + LOG4CXX_ERROR(logger_, "Failed to delete cache file"); + return false; + } + return true; +} + +bool HMICapabilitiesImpl::IsRequestsRequiredForCapabilities( + hmi_apis::FunctionID::eType function_id) const { + return helpers::in_range(requests_required_for_capabilities_, function_id); } void HMICapabilitiesImpl::set_ccpu_version(const std::string& ccpu_version) { @@ -1354,11 +2235,6 @@ const std::string& HMICapabilitiesImpl::ccpu_version() const { return ccpu_version_; } -bool HMICapabilitiesImpl::check_existing_json_member( - const Json::Value& json_member, const char* name_of_member) const { - return json_member.isMember(name_of_member); -} - void HMICapabilitiesImpl::convert_json_languages_to_obj( const Json::Value& json_languages, smart_objects::SmartObject& languages) const { @@ -1371,18 +2247,18 @@ void HMICapabilitiesImpl::convert_json_languages_to_obj( void HMICapabilitiesImpl::convert_audio_capability_to_obj( const Json::Value& capability, smart_objects::SmartObject& output_so) const { - if (check_existing_json_member(capability, "samplingRate")) { + if (JsonIsMemberSafe(capability, "samplingRate")) { output_so[strings::sampling_rate] = sampling_rate_enum.find(capability.get("samplingRate", "").asString()) ->second; } - if (check_existing_json_member(capability, "bitsPerSample")) { + if (JsonIsMemberSafe(capability, "bitsPerSample")) { output_so[strings::bits_per_sample] = bit_per_sample_enum .find(capability.get("bitsPerSample", "").asString()) ->second; } - if (check_existing_json_member(capability, "audioType")) { + if (JsonIsMemberSafe(capability, "audioType")) { output_so[strings::audio_type] = audio_type_enum.find(capability.get("audioType", "").asString()) ->second; |