From f0e50bf99171a05e3b5c4e0fc9392a3c14720695 Mon Sep 17 00:00:00 2001 From: Alexander Date: Wed, 22 Aug 2018 12:12:43 +0300 Subject: Add processing new light capabilities to set_interior_vehicle_data --- .../mobile/set_interior_vehicle_data_request.h | 13 +- .../include/rc_rpc_plugin/rc_module_constants.h | 6 +- .../mobile/set_interior_vehicle_data_request.cc | 414 +++++++++++++++------ 3 files changed, 313 insertions(+), 120 deletions(-) diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h index d5de4981c6..128c668ee9 100644 --- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h @@ -39,6 +39,11 @@ namespace rc_rpc_plugin { namespace app_mngr = application_manager; namespace commands { + +enum capabilitiesStatus { success, missedLightName, missedParam, readOnly }; + +typedef std::pair ModuleCapability; + class SetInteriorVehicleDataRequest : public RCCommandRequest { public: SetInteriorVehicleDataRequest( @@ -81,10 +86,12 @@ class SetInteriorVehicleDataRequest : public RCCommandRequest { /** * @brief Method that check if READ_ONLY parameters present - * @param request_params params from received message + * @param request_params params from received message, + * @param module_data_capabilities info for notification to mobile * @return true if present , false - otherwise */ - bool AreReadOnlyParamsPresent(const smart_objects::SmartObject& module_data); + bool AreReadOnlyParamsPresent(const smart_objects::SmartObject& module_data, + ModuleCapability& module_data_capabilities); /** * @brief Method that check if all request parameters are READ_ONLY @@ -95,7 +102,7 @@ class SetInteriorVehicleDataRequest : public RCCommandRequest { /** * @brief Method that cuts-off READ_ONLY parameters - * @param request_params params to handle + * @param module_data params to handle */ void CutOffReadOnlyParams(smart_objects::SmartObject& module_data); diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h index 195cec0ced..1951af1a24 100644 --- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h @@ -179,9 +179,9 @@ const char kHeatedMirrorsEnable[] = "heatedMirrorsEnable"; // LightControlData const char kLightState[] = "lightState"; -const char kStatus[] = "status"; -const char kDensity[] = "density"; -const char kColor[] = "color"; +const char kLightStatus[] = "status"; +const char kLightDensity[] = "density"; +const char kLightColor[] = "color"; // AudioControlData const char kSource[] = "source"; diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc index 17a492b5aa..e6f19a889c 100644 --- a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc @@ -59,10 +59,22 @@ std::vector GetModuleReadOnlyParams( module_ro_params.push_back(kSignalChangeThreshold); module_ro_params.push_back(kState); module_ro_params.push_back(kSisData); + } else if (enums_value::kLight == module_type) { + module_ro_params.push_back(kLightStatus); } + return module_ro_params; } +const std::map GetLightCapabilitiesMapping() { + std::map mapping = { + {message_params::kId, strings::kName}, + {message_params::kLightStatus, strings::kStatusAvailable}, + {message_params::kLightDensity, strings::kDensityAvailable}, + {message_params::kLightColor, strings::kRGBColorSpaceAvailable}}; + return mapping; +} + const std::map GetModuleDataToCapabilitiesMapping() { std::map mapping; // climate @@ -113,6 +125,7 @@ const std::map GetModuleDataToCapabilitiesMapping() { mapping["massageMode"] = "massageModeAvailable"; mapping["massageCushionFirmness"] = "massageCushionFirmnessAvailable"; mapping["memory"] = "memoryAvailable"; + // audio mapping["source"] = "sourceAvailable"; mapping["keepContext"] = "keepContextAvailable"; @@ -146,45 +159,98 @@ const std::string LightName(const smart_objects::SmartObject& light_name) { return ok ? name : "unknown"; } -bool CheckLightDataByCapabilities( +/** + * @brief Check whether the parameter exist in capabilities + * @param smart object of capabilities + * @param mapping - map of module data and capabilities + * @param request_parameter - string + * @param switched_off_result - ref of mobile_apis::Result + * @return success if parameter exist in capabilities missedParam otherwise + */ +capabilitiesStatus GetItemCapability( const smart_objects::SmartObject& capabilities, - const smart_objects::SmartObject& light_data) { + const std::map& mapping, + const std::string& request_parameter, + const mobile_apis::Result::eType& switched_off_result) { + const auto it = mapping.find(request_parameter); + + if (it == mapping.end()) { + LOG4CXX_DEBUG(logger_, + "Parameter " << request_parameter + << " doesn't exist in capabilities."); + return capabilitiesStatus::missedParam; + } + + const std::string& caps_key = it->second; + + LOG4CXX_DEBUG(logger_, + "Checking request parameter " + << request_parameter + << " with capabilities. Appropriate key is " << caps_key); + + if (!capabilities.keyExists(caps_key)) { + LOG4CXX_DEBUG(logger_, + "Capability " << caps_key + << " is missed in RemoteControl capabilities"); + return capabilitiesStatus::missedParam; + } + + if (!capabilities[caps_key].asBool()) { + LOG4CXX_DEBUG(logger_, + "Capability " + << caps_key + << " is switched off in RemoteControl capabilities"); + capabilitiesStatus status = capabilitiesStatus::missedParam; + if (mobile_apis::Result::READ_ONLY == switched_off_result) { + status = capabilitiesStatus::readOnly; + } + return status; + } + + return capabilitiesStatus::success; +} + +/** + * @brief Check whether the cpabilities for light allowed + * @param smart object of capabilities + * @param smart object of control_data + * @return pair of state and capability status - ModuleCapability + */ +ModuleCapability GetLightDataCapabilities( + const smart_objects::SmartObject& capabilities, + const smart_objects::SmartObject& control_data) { LOG4CXX_AUTO_TRACE(logger_); - std::map lightCapsMapping = { - {message_params::kId, strings::kName}, - {message_params::kDensity, strings::kDensityAvailable}, - {message_params::kColor, strings::kRGBColorSpaceAvailable}}; - auto it = light_data.map_begin(); - for (; it != light_data.map_end(); ++it) { - if (message_params::kStatus == it->first || - message_params::kId == it->first) { + std::map mapping = GetLightCapabilitiesMapping(); + + for (auto it = control_data.map_begin(); it != control_data.map_end(); ++it) { + const std::string& request_parameter = it->first; + + if (message_params::kId == request_parameter) { continue; } - const std::string& caps_key = lightCapsMapping[it->first]; - LOG4CXX_DEBUG(logger_, - "Checking request parameter " - << it->first << " with capabilities. Appropriate key is " - << caps_key); - - if (!capabilities.keyExists(caps_key)) { - LOG4CXX_DEBUG(logger_, - "Capability " - << caps_key - << " is missed in RemoteControl capabilities"); - return false; - } - if (!capabilities[caps_key].asBool()) { - LOG4CXX_DEBUG(logger_, - "Capability " - << caps_key - << " is switched off in RemoteControl capabilities"); - return false; + + const capabilitiesStatus status_item_capability = + GetItemCapability(capabilities, + mapping, + request_parameter, + mobile_apis::Result::READ_ONLY); + + if (capabilitiesStatus::success != status_item_capability) { + return std::make_pair(message_params::kLightState, + status_item_capability); } } - return true; + + return std::make_pair("", capabilitiesStatus::success); } -bool CheckLightNameByCapabilities( +/** + * @brief Check whether the light name exists in capabilities + * @param smart object of capabilities_status + * @param smart object of light_data + * @return pair of state and capability status - ModuleCapability + */ +ModuleCapability GetLightNameCapabilities( const smart_objects::SmartObject& capabilities_status, const smart_objects::SmartObject& light_data) { LOG4CXX_AUTO_TRACE(logger_); @@ -193,90 +259,101 @@ bool CheckLightNameByCapabilities( const smart_objects::SmartObject& so = *it; const int64_t current_id = so[message_params::kName].asInt(); if (current_id == light_data[message_params::kId].asInt()) { - return CheckLightDataByCapabilities(so, light_data); + return GetLightDataCapabilities(so, light_data); } } LOG4CXX_DEBUG(logger_, "There is no such light name in capabilities"); - return false; -} - -bool CheckRadioBandByCapabilities( - const smart_objects::SmartObject& capabilities_status, - const smart_objects::SmartObject& request_parameter) { - mobile_apis::RadioBand::eType radio_band = - static_cast(request_parameter.asUInt()); - if (mobile_apis::RadioBand::XM == radio_band) { - if (!capabilities_status.keyExists(strings::kSiriusxmRadioAvailable)) { - LOG4CXX_DEBUG(logger_, - "Capability " - << strings::kSiriusxmRadioAvailable - << " is missed in RemoteControl capabilities"); - return false; - } - if (!capabilities_status[strings::kSiriusxmRadioAvailable].asBool()) { - LOG4CXX_DEBUG(logger_, - "Capability " - << strings::kSiriusxmRadioAvailable - << " is switched off in RemoteControl capabilities"); - return false; - } - } - return true; + return std::make_pair(message_params::kLightState, + capabilitiesStatus::missedLightName); } -bool CheckControlDataByCapabilities( - const smart_objects::SmartObject& capabilities_status, +/** + * @brief Check whether the exists light data related to correspondent + * capabilities + * @param smart object of capabilities + * @param smart object of control_data + * @return pair of state and capability status - ModuleCapability + */ +ModuleCapability GetControlDataCapabilities( + const smart_objects::SmartObject& capabilities, const smart_objects::SmartObject& control_data) { LOG4CXX_AUTO_TRACE(logger_); std::map mapping = GetModuleDataToCapabilitiesMapping(); - auto it = control_data.map_begin(); - for (; it != control_data.map_end(); ++it) { + + for (auto it = control_data.map_begin(); it != control_data.map_end(); ++it) { const std::string& request_parameter = it->first; if (message_params::kId == request_parameter) { continue; } if (message_params::kLightState == request_parameter) { auto light_data = control_data[request_parameter].asArray()->begin(); + ModuleCapability light_capability = + std::make_pair("", capabilitiesStatus::success); + for (; light_data != control_data[request_parameter].asArray()->end(); ++light_data) { - if (!CheckLightNameByCapabilities( - capabilities_status[strings::kSupportedLights], *light_data)) { - return false; + light_capability = GetLightNameCapabilities( + capabilities[strings::kSupportedLights], *light_data); + + if (capabilitiesStatus::success != light_capability.second) { + return light_capability; } } - return true; - } - const std::string& caps_key = mapping[request_parameter]; - LOG4CXX_DEBUG(logger_, - "Checking request parameter " - << request_parameter - << " with capabilities. Appropriate key is " << caps_key); - - if (!capabilities_status.keyExists(caps_key)) { - LOG4CXX_DEBUG(logger_, - "Capability " - << caps_key - << " is missed in RemoteControl capabilities"); - return false; + + return light_capability; } - if (!capabilities_status[caps_key].asBool()) { - LOG4CXX_DEBUG(logger_, - "Capability " - << caps_key - << " is switched off in RemoteControl capabilities"); - return false; + + const capabilitiesStatus status_item_capability = + GetItemCapability(capabilities[0], + mapping, + request_parameter, + mobile_apis::Result::UNSUPPORTED_RESOURCE); + + if (capabilitiesStatus::success != status_item_capability) { + return std::make_pair("", status_item_capability); } - if (message_params::kBand == request_parameter && - !CheckRadioBandByCapabilities(capabilities_status, - control_data[request_parameter])) { - return false; + } + + return std::make_pair("", capabilitiesStatus::success); +} + +/** + * @brief Check whether the exists hmi data related to correspondent + * capabilities + * @param smart object of capabilities + * @param smart object of control_data + * @return pair of state and capability status - ModuleCapability + */ +ModuleCapability GetHmiControlDataCapabilities( + const smart_objects::SmartObject& capabilities, + const smart_objects::SmartObject& control_data) { + LOG4CXX_AUTO_TRACE(logger_); + std::map mapping = + GetModuleDataToCapabilitiesMapping(); + + for (auto it = control_data.map_begin(); it != control_data.map_end(); ++it) { + const capabilitiesStatus status_item_capability = + GetItemCapability(capabilities, + mapping, + it->first, + mobile_apis::Result::UNSUPPORTED_RESOURCE); + + if (capabilitiesStatus::success != status_item_capability) { + return std::make_pair("", status_item_capability); } } - return true; + + return std::make_pair("", capabilitiesStatus::success); } -bool CheckIfModuleDataExistInCapabilities( +/** + * @brief Check whether rc module data capabilities are presented + * @param smart object of rc_capabilities + * @param smart object of module_data + * @return pair of state and capability status - ModuleCapability + */ +ModuleCapability GetModuleDataCapabilities( const smart_objects::SmartObject& rc_capabilities, const smart_objects::SmartObject& module_data) { LOG4CXX_AUTO_TRACE(logger_); @@ -285,29 +362,31 @@ bool CheckIfModuleDataExistInCapabilities( const auto& get_module_data_key = RCHelpers::GetModuleTypeToDataMapping(); const auto& get_capabilities_key = RCHelpers::GetModuleTypeToCapabilitiesMapping(); + ModuleCapability module_data_capabilities = + std::make_pair("", capabilitiesStatus::missedParam); - bool is_module_data_valid = false; for (const auto& module_type : all_module_types) { const auto module_data_key = get_module_data_key(module_type); const auto capabilities_key = get_capabilities_key(module_type); if (module_data.keyExists(module_data_key)) { if (!rc_capabilities.keyExists(capabilities_key)) { LOG4CXX_DEBUG(logger_, module_data_key << " capabilities not present"); - return false; + return module_data_capabilities; } const smart_objects::SmartObject& caps = rc_capabilities[capabilities_key]; - if (message_params::kHmiSettingsControlData == module_data_key || - message_params::kLightControlData == module_data_key) { - is_module_data_valid = - CheckControlDataByCapabilities(caps, module_data[module_data_key]); + + if (message_params::kHmiSettingsControlData == module_data_key) { + module_data_capabilities = + GetHmiControlDataCapabilities(caps, module_data[module_data_key]); } else { - is_module_data_valid = CheckControlDataByCapabilities( - caps[0], module_data[module_data_key]); + module_data_capabilities = + GetControlDataCapabilities(caps, module_data[module_data_key]); } } } - return is_module_data_valid; + + return module_data_capabilities; } bool isModuleTypeAndDataMatch(const std::string& module_type, @@ -325,6 +404,35 @@ bool isModuleTypeAndDataMatch(const std::string& module_type, return module_type_and_data_match; } +mobile_apis::Result::eType PrepareResultCodeAndInfo( + const ModuleCapability module_data_capabilities, std::string& info) { + mobile_apis::Result::eType result_code = + mobile_apis::Result::UNSUPPORTED_RESOURCE; + if (message_params::kLightState == module_data_capabilities.first) { + switch (module_data_capabilities.second) { + case capabilitiesStatus::missedLightName: + info = "The requested LightName is not supported by the vehicle."; + break; + case capabilitiesStatus::missedParam: + info = + "The requested parameter of the given LightName is not supported " + "by the vehicle."; + break; + case capabilitiesStatus::readOnly: + info = "The requested parameter is read-only."; + result_code = mobile_apis::Result::READ_ONLY; + break; + default: + break; + } + + } else { + info = "Accessing not supported module data."; + } + return result_code; + LOG4CXX_WARN(logger_, info); +} + void SetInteriorVehicleDataRequest::Execute() { LOG4CXX_AUTO_TRACE(logger_); @@ -335,15 +443,22 @@ void SetInteriorVehicleDataRequest::Execute() { if (isModuleTypeAndDataMatch(module_type, module_data)) { const smart_objects::SmartObject* rc_capabilities = hmi_capabilities_.rc_capability(); - if (rc_capabilities && - !CheckIfModuleDataExistInCapabilities(*rc_capabilities, module_data)) { - LOG4CXX_WARN(logger_, "Accessing not supported module data"); - SetResourceState(ModuleType(), ResourceState::FREE); - SendResponse(false, - mobile_apis::Result::UNSUPPORTED_RESOURCE, - "Accessing not supported module data"); - return; + ModuleCapability module_data_capabilities; + + if (rc_capabilities) { + module_data_capabilities = + GetModuleDataCapabilities(*rc_capabilities, module_data); + + if (capabilitiesStatus::success != module_data_capabilities.second) { + SetResourceState(ModuleType(), ResourceState::FREE); + std::string info; + mobile_apis::Result::eType result = + PrepareResultCodeAndInfo(module_data_capabilities, info); + SendResponse(false, result, info.c_str()); + return; + } } + if (AreAllParamsReadOnly(module_data)) { LOG4CXX_WARN(logger_, "All request params in module type are READ ONLY!"); SetResourceState(ModuleType(), ResourceState::FREE); @@ -352,11 +467,27 @@ void SetInteriorVehicleDataRequest::Execute() { "All request params in module type are READ ONLY!"); return; } - if (AreReadOnlyParamsPresent(module_data)) { + + module_data_capabilities = std::make_pair("", capabilitiesStatus::success); + + if (AreReadOnlyParamsPresent(module_data, module_data_capabilities)) { LOG4CXX_DEBUG(logger_, "Request module type has READ ONLY parameters"); + + if (enums_value::kLight == module_data_capabilities.first && + capabilitiesStatus::success != module_data_capabilities.second) { + SetResourceState(ModuleType(), ResourceState::FREE); + SendResponse( + false, + mobile_apis::Result::READ_ONLY, + "The LightStatus enum passed is READ ONLY and cannot be written."); + return; + } + LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameters... "); + CutOffReadOnlyParams(module_data); } + application_manager_.RemoveHMIFakeParameters(message_); app_mngr::ApplicationSharedPtr app = @@ -478,6 +609,8 @@ bool SetInteriorVehicleDataRequest::AreAllParamsReadOnly( return false; } } + + LOG4CXX_DEBUG(logger_, "All params are ReadOnly"); return true; } @@ -487,33 +620,84 @@ bool CheckReadOnlyParamsForAudio( const auto& equalizer_settings = module_type_params[message_params::kEqualizerSettings]; auto it = equalizer_settings.asArray()->begin(); + for (; it != equalizer_settings.asArray()->end(); ++it) { if (it->keyExists(message_params::kChannelName)) { LOG4CXX_DEBUG(logger_, - " READ ONLY parameter: " << message_params::kChannelName); + "READ ONLY parameter. ChannelName = " + << (*it)[message_params::kChannelName].asString()); return true; } } } + + return false; +} + +bool CheckReadOnlyParamsForLight( + const smart_objects::SmartObject& module_type_params) { + if (module_type_params.keyExists(message_params::kLightState)) { + const auto& light_state = module_type_params[message_params::kLightState]; + auto it = light_state.asArray()->begin(); + + for (; it != light_state.asArray()->end(); ++it) { + if (it->keyExists(message_params::kLightStatus)) { + const mobile_apis::LightStatus::eType light_status = + static_cast( + (*it)[message_params::kLightStatus].asUInt()); + + if (helpers::Compare(light_status, + mobile_apis::LightStatus::RAMP_UP, + mobile_apis::LightStatus::RAMP_DOWN, + mobile_apis::LightStatus::UNKNOWN, + mobile_apis::LightStatus::INVALID)) { + LOG4CXX_DEBUG(logger_, + "READ ONLY parameter. Status = " + << (*it)[message_params::kLightStatus].asInt()); + return true; + } + } + } + } + return false; } bool SetInteriorVehicleDataRequest::AreReadOnlyParamsPresent( - const smart_objects::SmartObject& module_data) { + const smart_objects::SmartObject& module_data, + ModuleCapability& module_data_capabilities) { LOG4CXX_AUTO_TRACE(logger_); const smart_objects::SmartObject& module_type_params = ControlData(module_data); - auto it = module_type_params.map_begin(); const std::string module_type = ModuleType(); - std::vector ro_params = GetModuleReadOnlyParams(module_type); + if (enums_value::kAudio == module_type) { return CheckReadOnlyParamsForAudio(module_type_params); } + + if (enums_value::kLight == module_type) { + const bool result = CheckReadOnlyParamsForLight(module_type_params); + + if (result) { + module_data_capabilities = + std::make_pair(module_type, capabilitiesStatus::readOnly); + } + + return result; + } + + const std::vector ro_params = + GetModuleReadOnlyParams(module_type); + auto it = module_type_params.map_begin(); + for (; it != module_type_params.map_end(); ++it) { if (helpers::in_range(ro_params, it->first)) { return true; } } + return false; } @@ -529,11 +713,13 @@ void SetInteriorVehicleDataRequest::CutOffReadOnlyParams( if (module_type_params.keyExists(it)) { if (enums_value::kClimate == module_type) { module_data[message_params::kClimateControlData].erase(it); - LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it); } else if (enums_value::kRadio == module_type) { module_data[message_params::kRadioControlData].erase(it); - LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it); + } else { + continue; } + + LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it); } } -- cgit v1.2.1