virtual void Run();
private:
+ std::string CommonLanguageToString(
+ hmi_apis::Common_Language::eType language);
DISALLOW_COPY_AND_ASSIGN(SDLGetUserFriendlyMessageRequest);
};
*/
static void SendOnSDLConsentNeeded(const policy::DeviceParams& device_info);
+ /**
+ * @brief Send GetUserFriendlyMessage response to HMI
+ * @param msg Appopriate messages params
+ * @param correlation_id Correlation id of request
+ */
+ static void SendGetUserFriendlyMessageResponse(
+ const std::vector<policy::UserFriendlyMessage>& msg,
+ uint32_t correlation_id);
+
/*
* @brief Sends notification to HMI to start video streaming
*
uint32_t application_id = 0);
/**
- * @brief Process application permission, which was set by user
- * @param List of user-defined permissions for application
- */
- void OnAllowAppResponse(PermissionsList& list_of_permissions);
-
- /**
- * @brief Process application permission, which was set by user
- * @param List of user-defined permissions for application
- * @param Unique application id, if omitted - allow/disallow all
- * applications
- */
- void OnAllowAppNotification(PermissionsList& list_of_permissions,
- uint32_t appication_id = 0);
-
- /**
* @brief Increment counter for ignition cycles
*/
void OnIgnitionCycleOver();
*/
void OnAppPermissionConsent(const PermissionConsent& permissions);
+ /**
+ * @brief Get appropriate message parameters and send them with response
+ * to HMI
+ * @param message_codes RPC message codes
+ * @param language Language
+ * @param correlation_id correlation id of request
+ */
+ void OnGetUserFriendlyMessage(const std::vector<std::string>& message_codes,
+ const std::string& language,
+ uint32_t correlation_id);
+
protected:
/**
* Starts next retry exchange policy table
*/
#include "application_manager/commands/hmi/sdl_get_user_friendly_message_request.h"
+#include "application_manager/application_manager_impl.h"
+#include "application_manager/policies/policy_handler.h"
namespace application_manager {
namespace commands {
-SDLGetUserFriendlyMessageRequest::SDLGetUserFriendlyMessageRequest(const MessageSharedPtr& message)
+SDLGetUserFriendlyMessageRequest::SDLGetUserFriendlyMessageRequest(
+ const MessageSharedPtr& message)
: RequestFromHMI(message) {
}
void SDLGetUserFriendlyMessageRequest::Run() {
LOG4CXX_INFO(logger_, "SDLGetUserFriendlyMessageRequest::Run");
+ const std::string messageCodes = "messageCodes";
+ if (!(*message_)[strings::msg_params].keyExists(messageCodes)) {
+ LOG4CXX_WARN(logger_,
+ "Mandatory parameter '"+messageCodes+"'' is missing");
+ return;
+ }
+ smart_objects::SmartArray* msg =
+ (*message_)[strings::msg_params][messageCodes].asArray();
+
+ std::vector<std::string> msg_codes;
+
+ smart_objects::SmartArray::const_iterator it = msg->begin();
+ smart_objects::SmartArray::const_iterator it_end = msg->end();
+ for (; it != it_end; ++it) {
+ msg_codes.push_back((*it).asString());
+ }
+
+ std::string required_language;
+ const std::string language = "language";
+ if ((*message_)[strings::msg_params].keyExists(language)) {
+ uint32_t lang_code = (*message_)[strings::msg_params][language].asUInt();
+ required_language = CommonLanguageToString(
+ static_cast<hmi_apis::Common_Language::eType>(lang_code));
+ } else {
+ hmi_apis::Common_Language::eType ui_language =
+ application_manager::ApplicationManagerImpl::instance()
+ ->hmi_capabilities().active_ui_language();
+
+ required_language = CommonLanguageToString(ui_language);
+ }
+
+ policy::PolicyHandler::instance()->OnGetUserFriendlyMessage(
+ msg_codes, required_language,
+ (*message_)[strings::params][strings::correlation_id].asInt());
+}
+
+std::string SDLGetUserFriendlyMessageRequest::CommonLanguageToString(
+ hmi_apis::Common_Language::eType language) {
+ switch (language) {
+ case hmi_apis::Common_Language::EN_US:
+ return "en-us";
+ case hmi_apis::Common_Language::ES_MX:
+ return "es-mx";
+ case hmi_apis::Common_Language::FR_CA:
+ return "fr-ca";
+ case hmi_apis::Common_Language::DE_DE:
+ return "de-de";
+ case hmi_apis::Common_Language::ES_ES:
+ return "es-es";
+ case hmi_apis::Common_Language::EN_GB:
+ return "en-gb";
+ case hmi_apis::Common_Language::RU_RU:
+ return "ru-ru";
+ case hmi_apis::Common_Language::TR_TR:
+ return "tr-tr";
+ case hmi_apis::Common_Language::PL_PL:
+ return "pl-pl";
+ case hmi_apis::Common_Language::FR_FR:
+ return "fr-fr";
+ case hmi_apis::Common_Language::IT_IT:
+ return "it-it";
+ case hmi_apis::Common_Language::SV_SE:
+ return "sv-se";
+ case hmi_apis::Common_Language::PT_PT:
+ return "pt-pt";
+ case hmi_apis::Common_Language::NL_NL:
+ return "nl-nl";
+ case hmi_apis::Common_Language::EN_AU:
+ return "en-au";
+ case hmi_apis::Common_Language::ZH_CN:
+ return "zh-cn";
+ case hmi_apis::Common_Language::ZH_TW:
+ return "zh-tw";
+ case hmi_apis::Common_Language::JA_JP:
+ return "ja-jp";
+ case hmi_apis::Common_Language::AR_SA:
+ return "as-sa";
+ case hmi_apis::Common_Language::KO_KR:
+ return "ko-kr";
+ case hmi_apis::Common_Language::PT_BR:
+ return "pt-br";
+ case hmi_apis::Common_Language::CS_CZ:
+ return "cs-cz";
+ case hmi_apis::Common_Language::DA_DK:
+ return "da-dk";
+ case hmi_apis::Common_Language::NO_NO:
+ return "no-no";
+ default:
+ LOG4CXX_WARN(logger_, "Language is unknown.");
+ return "";
+ }
}
} // namespace commands
*/
#include "application_manager/commands/hmi/sdl_get_user_friendly_message_response.h"
+#include "application_manager/application_manager_impl.h"
namespace application_manager {
void SDLGetUserFriendlyMessageResponse::Run() {
LOG4CXX_INFO(logger_, "SDLGetUserFriendlyMessageResponse::Run");
+ (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_;
+ (*message_)[strings::params][strings::protocol_version] = protocol_version_;
+
+ ApplicationManagerImpl::instance()->SendMessageToHMI(message_);
}
} // namespace commands
#include "utils/macro.h"
#include "application_manager/application_manager_impl.h"
#include "application_manager/message_helper.h"
-//#include "application_manager/policies/policy_handler.h"
#include "application_manager/commands/command_impl.h"
#include "connection_handler/connection_handler_impl.h"
#include "application_manager/application.h"
ApplicationManagerImpl::instance()->ManageHMICommand(message);
}
+void MessageHelper::SendGetUserFriendlyMessageResponse(
+ const std::vector<policy::UserFriendlyMessage>& msg,
+ uint32_t correlation_id) {
+ smart_objects::SmartObject* message = new smart_objects::SmartObject(
+ smart_objects::SmartType_Map);
+ if (!message) {
+ return;
+ }
+
+ (*message)[strings::params][strings::function_id] =
+ hmi_apis::FunctionID::SDL_GetUserFriendlyMessage;
+ (*message)[strings::params][strings::message_type] =
+ MessageType::kResponse;
+ (*message)[strings::params][strings::correlation_id] = correlation_id;
+ (*message)[strings::params]["code"] = 0;
+
+ // If no any messages found - skip sending of "messages" param
+ if (msg.empty()) {
+ ApplicationManagerImpl::instance()->ManageHMICommand(message);
+ }
+
+ const std::string messages = "messages";
+ (*message)[strings::msg_params][messages] =
+ smart_objects::SmartObject(smart_objects::SmartType_Array);
+
+ smart_objects::SmartObject& user_friendly_messages =
+ (*message)[strings::msg_params][messages];
+
+
+ const std::string tts = "ttsString";
+ const std::string label = "label";
+ const std::string line1 = "line1";
+ const std::string line2 = "line2";
+ const std::string textBody = "textBody";
+
+ std::vector<policy::UserFriendlyMessage>::const_iterator it = msg.begin();
+ std::vector<policy::UserFriendlyMessage>::const_iterator it_end = msg.end();
+ for (uint32_t index = 0; it != it_end; ++it, ++index) {
+ user_friendly_messages[index] = smart_objects::SmartObject(
+ smart_objects::SmartType_Map);
+
+ smart_objects::SmartObject& msg = user_friendly_messages[index];
+
+ if (!it->tts.empty()) {
+ msg[tts] = it->tts;
+ }
+ if (!it->label.empty()) {
+ msg[label] = it->label;
+ }
+ if (!it->line1.empty()) {
+ msg[line1] = it->line1;
+ }
+ if (!it->line2.empty()) {
+ msg[line2] = it->line2;
+ }
+ if (!it->text_body.empty()) {
+ msg[textBody] = it->text_body;
+ }
+ }
+
+ PrintSmartObject(*message);
+
+ ApplicationManagerImpl::instance()->ManageHMICommand(message);
+}
+
smart_objects::SmartObject* MessageHelper::CreateNegativeResponse(
uint32_t connection_key, int32_t function_id, uint32_t correlation_id,
int32_t result_code) {
//TODO(AOleynik): Handle situation for all apps (policy_app_id is empty)
}
+void PolicyHandler::OnGetUserFriendlyMessage(
+ const std::vector<std::string>& message_codes, const std::string& language,
+ uint32_t correlation_id) {
+ LOG4CXX_INFO(logger_, "OnGetUserFriendlyMessage");
+ std::vector<UserFriendlyMessage> result =
+ policy_manager_->GetUserFriendlyMessages(message_codes, language);
+ // Send response to HMI with gathered data
+ application_manager::MessageHelper::SendGetUserFriendlyMessageResponse(
+ result, correlation_id);
+}
+
void PolicyHandler::OnAppRevoked(const std::string& policy_app_id) {
LOG4CXX_INFO(logger_, "OnAppRevoked");
const ApplicationList app_list =
// TODO(AOleynik): Handle situation, if general functionality is concerned
}
-void PolicyHandler::SendAllowApp(const PermissionsList& list_of_permissions,
- uint32_t application_id) {
- LOG4CXX_INFO(logger_,
- "Sending allow request for application id:" << application_id);
- // TODO(PV): change
- /*application_manager::MessageHelper::SendAllowAppRequest(list_of_permissions,
- application_id);*/
-}
-
-void PolicyHandler::OnAllowAppResponse(PermissionsList& list_of_permissions) {
- // TODO(AOleynik): Impelement response processing for user-defined permissions
- // for application
-}
-
-void PolicyHandler::OnAllowAppNotification(PermissionsList& list_of_permissions,
- uint32_t appication_id) {
- // TODO(AOleynik): Implement notification processing for user-defined
- // permissions for applicaiton
-}
-
void PolicyHandler::OnIgnitionCycleOver() {
LOG4CXX_INFO(logger_, "OnIgnitionCycleOver");
policy_manager_->IncrementIgnitionCycles();
projects / profile / ivi / smartdevicelink.git / commitdiff