1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
#include "rc_rpc_plugin/rc_helpers.h"
#include "application_manager/commands/command_impl.h"
#include "application_manager/message.h"
#include "application_manager/smart_object_keys.h"
#include "rc_rpc_plugin/rc_module_constants.h"
#include "rc_rpc_plugin/rc_rpc_plugin.h"
namespace rc_rpc_plugin {
CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule");
const std::function<std::string(const std::string& module_type)>
RCHelpers::GetModuleTypeToDataMapping() {
auto mapping_lambda = [](const std::string& module_type) -> std::string {
static std::map<std::string, std::string> mapping = {
{enums_value::kClimate, message_params::kClimateControlData},
{enums_value::kRadio, message_params::kRadioControlData},
{enums_value::kSeat, message_params::kSeatControlData},
{enums_value::kAudio, message_params::kAudioControlData},
{enums_value::kLight, message_params::kLightControlData},
{enums_value::kHmiSettings, message_params::kHmiSettingsControlData}};
auto it = mapping.find(module_type);
if (mapping.end() == it) {
LOG4CXX_ERROR(logger_, "Unknown module type" << module_type);
return std::string();
}
return it->second;
};
return mapping_lambda;
}
const std::function<std::string(const std::string& module_type)>
RCHelpers::GetModuleTypeToCapabilitiesMapping() {
auto mapping_lambda = [](const std::string& module_type) -> std::string {
static std::map<std::string, std::string> mapping = {
{enums_value::kClimate, strings::kclimateControlCapabilities},
{enums_value::kRadio, strings::kradioControlCapabilities},
{enums_value::kSeat, strings::kseatControlCapabilities},
{enums_value::kAudio, strings::kaudioControlCapabilities},
{enums_value::kLight, strings::klightControlCapabilities},
{enums_value::kHmiSettings, strings::khmiSettingsControlCapabilities}};
auto it = mapping.find(module_type);
if (mapping.end() == it) {
LOG4CXX_ERROR(logger_, "Unknown module type" << module_type);
return std::string();
}
return it->second;
};
return mapping_lambda;
}
const std::vector<std::string> RCHelpers::GetModulesList() {
using namespace enums_value;
return {kClimate, kRadio, kSeat, kAudio, kLight, kHmiSettings};
}
RCAppExtensionPtr RCHelpers::GetRCExtension(
application_manager::Application& app) {
auto extension_interface = app.QueryInterface(RCRPCPlugin::kRCPluginID);
auto extension =
std::static_pointer_cast<RCAppExtension>(extension_interface);
return extension;
}
smart_objects::SmartObjectSPtr RCHelpers::CreateUnsubscribeRequestToHMI(
const std::string& module_type, const uint32_t correlation_id) {
using namespace smart_objects;
namespace commands = application_manager::commands;
namespace am_strings = application_manager::strings;
SmartObjectSPtr message = std::make_shared<SmartObject>(SmartType_Map);
SmartObject& params = (*message)[am_strings::params];
SmartObject& msg_params = (*message)[am_strings::msg_params];
params[am_strings::message_type] =
static_cast<int>(application_manager::kRequest);
params[am_strings::protocol_version] =
commands::CommandImpl::protocol_version_;
params[am_strings::protocol_type] = commands::CommandImpl::hmi_protocol_type_;
params[am_strings::correlation_id] = correlation_id;
params[am_strings::function_id] =
hmi_apis::FunctionID::RC_GetInteriorVehicleData;
msg_params[message_params::kSubscribe] = false;
msg_params[message_params::kModuleType] = module_type;
return message;
}
std::vector<application_manager::ApplicationSharedPtr>
RCHelpers::AppsSubscribedToModuleType(
application_manager::ApplicationManager& app_mngr,
const std::string& module_type) {
std::vector<application_manager::ApplicationSharedPtr> result;
auto rc_apps = RCRPCPlugin::GetRCApplications(app_mngr);
for (auto& app : rc_apps) {
auto rc_ext = RCHelpers::GetRCExtension(*app);
DCHECK_OR_RETURN(rc_ext, result);
if (rc_ext->IsSubscibedToInteriorVehicleData(module_type)) {
result.push_back(app);
}
}
return result;
}
RCHelpers::AppsModules RCHelpers::GetApplicationsAllowedModules(
app_mngr::ApplicationManager& app_mngr) {
auto apps_list = RCRPCPlugin::GetRCApplications(app_mngr);
RCHelpers::AppsModules result;
for (auto& app_ptr : apps_list) {
std::vector<std::string> allowed_modules;
app_mngr.GetPolicyHandler().GetModuleTypes(app_ptr->policy_app_id(),
&allowed_modules);
std::sort(allowed_modules.begin(), allowed_modules.end());
result[app_ptr] = allowed_modules;
}
return result;
}
void RCHelpers::RemoveRedundantGPSDataFromIVDataMsg(
smart_objects::SmartObject& msg_params) {
using namespace message_params;
using namespace application_manager::strings;
LOG4CXX_AUTO_TRACE(logger_);
auto& module_data = msg_params[kModuleData];
if (!module_data.keyExists(kRadioControlData) ||
!module_data[kRadioControlData].keyExists(kSisData) ||
!module_data[kRadioControlData][kSisData].keyExists(station_location)) {
return;
}
auto& location_data =
module_data[kRadioControlData][kSisData][station_location];
auto new_location_data =
smart_objects::SmartObject(smart_objects::SmartType_Map);
new_location_data[latitude_degrees] = location_data[latitude_degrees];
new_location_data[longitude_degrees] = location_data[longitude_degrees];
if (location_data.keyExists(altitude)) {
new_location_data[altitude] = location_data[altitude];
location_data = new_location_data;
}
}
} // namespace rc_rpc_plugin
|
