diff options
Diffstat (limited to 'src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc')
| -rw-r--r-- | src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc | 536 |
1 files changed, 459 insertions, 77 deletions
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 83bb526076..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 @@ -33,6 +33,7 @@ #include "rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h" #include "rc_rpc_plugin/rc_module_constants.h" #include "rc_rpc_plugin/rc_rpc_plugin.h" +#include "rc_rpc_plugin/rc_helpers.h" #include "smart_objects/enum_schema_item.h" #include "utils/macro.h" #include "json/json.h" @@ -57,15 +58,20 @@ std::vector<std::string> GetModuleReadOnlyParams( module_ro_params.push_back(kSignalStrength); 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<std::string, std::string> GetModuleTypeToDataMapping() { +const std::map<std::string, std::string> GetLightCapabilitiesMapping() { std::map<std::string, std::string> mapping = { - {enums_value::kRadio, message_params::kRadioControlData}, - {enums_value::kClimate, message_params::kClimateControlData}, - {enums_value::kSeat, message_params::kSeatControlData}}; + {message_params::kId, strings::kName}, + {message_params::kLightStatus, strings::kStatusAvailable}, + {message_params::kLightDensity, strings::kDensityAvailable}, + {message_params::kLightColor, strings::kRGBColorSpaceAvailable}}; return mapping; } @@ -82,6 +88,10 @@ const std::map<std::string, std::string> GetModuleDataToCapabilitiesMapping() { mapping["dualModeEnable"] = "dualModeEnableAvailable"; mapping["acMaxEnable"] = "acMaxEnableAvailable"; mapping["ventilationMode"] = "ventilationModeAvailable"; + mapping["heatedSteeringWheelEnable"] = "heatedSteeringWheelAvailable"; + mapping["heatedWindshieldEnable"] = "heatedWindshieldAvailable"; + mapping["heatedMirrorsEnable"] = "heatedMirrorsAvailable"; + mapping["heatedRearWindowEnable"] = "heatedRearWindowAvailable"; // radio mapping["band"] = "radioBandAvailable"; @@ -90,10 +100,12 @@ const std::map<std::string, std::string> GetModuleDataToCapabilitiesMapping() { mapping["rdsData"] = "rdsDataAvailable"; mapping["availableHDs"] = "availableHDsAvailable"; mapping["hdChannel"] = "availableHDsAvailable"; + mapping["hdRadioEnable"] = "hdRadioEnableAvailable"; mapping["signalStrength"] = "signalStrengthAvailable"; mapping["signalChangeThreshold"] = "signalChangeThresholdAvailable"; mapping["radioEnable"] = "radioEnableAvailable"; mapping["state"] = "stateAvailable"; + mapping["sisData"] = "sisDataAvailable"; // seat mapping["heatingEnabled"] = "heatingEnabledAvailable"; @@ -114,6 +126,17 @@ const std::map<std::string, std::string> GetModuleDataToCapabilitiesMapping() { mapping["massageCushionFirmness"] = "massageCushionFirmnessAvailable"; mapping["memory"] = "memoryAvailable"; + // audio + mapping["source"] = "sourceAvailable"; + mapping["keepContext"] = "keepContextAvailable"; + mapping["volume"] = "volumeAvailable"; + mapping["equalizerSettings"] = "equalizerAvailable"; + + // hmi settings + mapping["distanceUnit"] = "distanceUnitAvailable"; + mapping["temperatureUnit"] = "temperatureUnitAvailable"; + mapping["displayMode"] = "displayModeUnitAvailable"; + return mapping; } } // namespace @@ -122,94 +145,294 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule") SetInteriorVehicleDataRequest::SetInteriorVehicleDataRequest( const app_mngr::commands::MessageSharedPtr& message, - app_mngr::ApplicationManager& application_manager, - app_mngr::rpc_service::RPCService& rpc_service, - app_mngr::HMICapabilities& hmi_capabilities, - policy::PolicyHandlerInterface& policy_handle, - ResourceAllocationManager& resource_allocation_manager) - : RCCommandRequest(message, - application_manager, - rpc_service, - hmi_capabilities, - policy_handle, - resource_allocation_manager) {} + const RCCommandParams& params) + : RCCommandRequest(message, params) {} SetInteriorVehicleDataRequest::~SetInteriorVehicleDataRequest() {} -bool CheckControlDataByCapabilities( - const smart_objects::SmartObject& module_caps, +const std::string LightName(const smart_objects::SmartObject& light_name) { + const char* name; + const bool ok = NsSmartDeviceLink::NsSmartObjects:: + EnumConversionHelper<mobile_apis::LightName::eType>::EnumToCString( + static_cast<mobile_apis::LightName::eType>(light_name.asUInt()), + &name); + return ok ? name : "unknown"; +} + +/** + * @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 std::map<std::string, std::string>& 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<std::string, std::string> 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 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 std::make_pair("", capabilitiesStatus::success); +} + +/** + * @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_); + auto it = capabilities_status.asArray()->begin(); + for (; it != capabilities_status.asArray()->end(); ++it) { + 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 GetLightDataCapabilities(so, light_data); + } + } + LOG4CXX_DEBUG(logger_, "There is no such light name in capabilities"); + return std::make_pair(message_params::kLightState, + capabilitiesStatus::missedLightName); +} + +/** + * @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<std::string, std::string> mapping = GetModuleDataToCapabilitiesMapping(); - const smart_objects::SmartObject& capabilities_status = module_caps[0]; - 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; } - 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; + 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) { + light_capability = GetLightNameCapabilities( + capabilities[strings::kSupportedLights], *light_data); + + if (capabilitiesStatus::success != light_capability.second) { + return light_capability; + } + } + + 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); } } - return true; + + return std::make_pair("", capabilitiesStatus::success); } -bool CheckIfModuleDataExistInCapabilities( +/** + * @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<std::string, std::string> 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 std::make_pair("", capabilitiesStatus::success); +} + +/** + * @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_); - const std::map<std::string, std::string> params = { - {message_params::kRadioControlData, strings::kradioControlCapabilities}, - {message_params::kClimateControlData, - strings::kclimateControlCapabilities}, - {message_params::kSeatControlData, strings::kseatControlCapabilities}}; - bool is_module_data_valid = false; - for (const auto& param : params) { - if (module_data.keyExists(param.first)) { - if (!rc_capabilities.keyExists(param.second)) { - LOG4CXX_DEBUG(logger_, param.first << " capabilities not present"); - return false; + + const auto& all_module_types = RCHelpers::GetModulesList(); + const auto& get_module_data_key = RCHelpers::GetModuleTypeToDataMapping(); + const auto& get_capabilities_key = + RCHelpers::GetModuleTypeToCapabilitiesMapping(); + ModuleCapability module_data_capabilities = + std::make_pair("", capabilitiesStatus::missedParam); + + 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 module_data_capabilities; + } + const smart_objects::SmartObject& caps = + rc_capabilities[capabilities_key]; + + if (message_params::kHmiSettingsControlData == module_data_key) { + module_data_capabilities = + GetHmiControlDataCapabilities(caps, module_data[module_data_key]); + } else { + module_data_capabilities = + GetControlDataCapabilities(caps, module_data[module_data_key]); } - const smart_objects::SmartObject& caps = rc_capabilities[param.second]; - is_module_data_valid = - CheckControlDataByCapabilities(caps, module_data[param.first]); } } - return is_module_data_valid; + + return module_data_capabilities; } bool isModuleTypeAndDataMatch(const std::string& module_type, const smart_objects::SmartObject& module_data) { LOG4CXX_AUTO_TRACE(logger_); - std::map<std::string, std::string> data_mapping = - GetModuleTypeToDataMapping(); + const auto& all_module_types = RCHelpers::GetModulesList(); + const auto& data_mapping = RCHelpers::GetModuleTypeToDataMapping(); bool module_type_and_data_match = false; - for (const auto& data : data_mapping) { - if (data.first == module_type) { - module_type_and_data_match = module_data.keyExists(data.second); + for (const auto& type : all_module_types) { + if (type == module_type) { + module_type_and_data_match = module_data.keyExists(data_mapping(type)); break; } } 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_); @@ -220,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); @@ -237,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 = @@ -249,6 +495,20 @@ void SetInteriorVehicleDataRequest::Execute() { (*message_)[app_mngr::strings::msg_params][app_mngr::strings::app_id] = app->app_id(); + const bool app_wants_to_set_audio_src = + module_data.keyExists(message_params::kAudioControlData) && + module_data[message_params::kAudioControlData].keyExists( + message_params::kSource); + + if (app_wants_to_set_audio_src && !app->IsAllowedToChangeAudioSource()) { + LOG4CXX_WARN(logger_, "App is not allowed to change audio source"); + SetResourceState(ModuleType(), ResourceState::FREE); + SendResponse(false, + mobile_apis::Result::REJECTED, + "App is not allowed to change audio source"); + return; + } + SendHMIRequest(hmi_apis::FunctionID::RC_SetInteriorVehicleData, &(*message_)[app_mngr::strings::msg_params], true); @@ -284,6 +544,11 @@ void SetInteriorVehicleDataRequest::on_event( smart_objects::SmartObject response_params; if (result) { response_params = hmi_response[app_mngr::strings::msg_params]; + if (enums_value::kAudio == ModuleType()) { + CheckAudioSource(( + *message_)[app_mngr::strings::msg_params][message_params::kModuleData] + [message_params::kAudioControlData]); + } } std::string info; GetInfo(hmi_response, info); @@ -294,17 +559,44 @@ void SetInteriorVehicleDataRequest::on_event( const smart_objects::SmartObject& SetInteriorVehicleDataRequest::ControlData( const smart_objects::SmartObject& module_data) { const std::string module_type = ModuleType(); - std::map<std::string, std::string> data_mapping = - GetModuleTypeToDataMapping(); - for (const auto& data : data_mapping) { - if (data.first == module_type) { - return module_data[data.second]; + + const auto& all_module_types = RCHelpers::GetModulesList(); + const auto& data_mapping = RCHelpers::GetModuleTypeToDataMapping(); + for (const auto& type : all_module_types) { + if (type == module_type) { + return module_data[data_mapping(type)]; } } NOTREACHED(); return module_data[0]; } +void SetInteriorVehicleDataRequest::CheckAudioSource( + const smart_objects::SmartObject& audio_data) { + LOG4CXX_AUTO_TRACE(logger_); + const bool should_keep_context = + audio_data.keyExists(message_params::kKeepContext) && + audio_data[message_params::kKeepContext].asBool(); + const bool switch_source_from_app = + mobile_apis::PrimaryAudioSource::MOBILE_APP == + application_manager_.get_current_audio_source() && + mobile_apis::PrimaryAudioSource::MOBILE_APP != + audio_data[message_params::kSource].asInt(); + if (!should_keep_context && switch_source_from_app) { + app_mngr::ApplicationSharedPtr app = + application_manager_.application(connection_key()); + if (app->mobile_projection_enabled()) { + application_manager_.ChangeAppsHMILevel( + app->app_id(), mobile_apis::HMILevel::eType::HMI_LIMITED); + } else { + application_manager_.ChangeAppsHMILevel( + app->app_id(), mobile_apis::HMILevel::eType::HMI_BACKGROUND); + } + } + application_manager_.set_current_audio_source( + audio_data[message_params::kSource].asUInt()); +} + bool SetInteriorVehicleDataRequest::AreAllParamsReadOnly( const smart_objects::SmartObject& module_data) { LOG4CXX_AUTO_TRACE(logger_); @@ -317,21 +609,95 @@ bool SetInteriorVehicleDataRequest::AreAllParamsReadOnly( return false; } } + + LOG4CXX_DEBUG(logger_, "All params are ReadOnly"); return true; } +bool CheckReadOnlyParamsForAudio( + const smart_objects::SmartObject& module_type_params) { + if (module_type_params.keyExists(message_params::kEqualizerSettings)) { + 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. 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<mobile_apis::LightStatus::eType>( + (*it)[message_params::kLightStatus].asUInt()); + + if (helpers::Compare<mobile_apis::LightStatus::eType, + helpers::EQ, + helpers::ONE>(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); + const std::string module_type = ModuleType(); + + 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<std::string> ro_params = + GetModuleReadOnlyParams(module_type); auto it = module_type_params.map_begin(); - std::vector<std::string> ro_params = GetModuleReadOnlyParams(ModuleType()); + for (; it != module_type_params.map_end(); ++it) { if (helpers::in_range(ro_params, it->first)) { return true; } } + return false; } @@ -347,10 +713,26 @@ 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); + } + } + + if (enums_value::kAudio == module_type) { + auto& equalizer_settings = module_data[message_params::kAudioControlData] + [message_params::kEqualizerSettings]; + auto it = equalizer_settings.asArray()->begin(); + for (; it != equalizer_settings.asArray()->end(); ++it) { + if (it->keyExists(message_params::kChannelName)) { + it->erase(message_params::kChannelName); + LOG4CXX_DEBUG(logger_, + "Cutting-off READ ONLY parameter: " + << message_params::kChannelName); } } } |