diff options
Diffstat (limited to 'src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc')
| -rw-r--r-- | src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc | 273 |
1 files changed, 166 insertions, 107 deletions
diff --git a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc index 14a94fd1a2..cbdaa713b8 100644 --- a/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc +++ b/src/components/application_manager/rpc_plugins/sdl_rpc_plugin/src/commands/mobile/register_app_interface_request.cc @@ -43,6 +43,7 @@ #include "application_manager/application_manager.h" #include "application_manager/helpers/application_helper.h" #include "application_manager/message_helper.h" +#include "application_manager/plugin_manager/plugin_keys.h" #include "application_manager/policies/policy_handler.h" #include "application_manager/policies/policy_handler_interface.h" #include "application_manager/resumption/resume_ctrl.h" @@ -296,50 +297,77 @@ void RegisterAppInterfaceRequest::Run() { return; } + mobile_apis::Result::eType coincidence_result = CheckCoincidence(); + std::vector<ApplicationSharedPtr> duplicate_apps; - mobile_apis::Result::eType coincidence_result = - CheckCoincidence(duplicate_apps); - - if (mobile_apis::Result::DUPLICATE_NAME == coincidence_result && - duplicate_apps.size() == 1) { - ApplicationSharedPtr duplicate_app = duplicate_apps.front(); - bool error_response = true; - if (duplicate_app->is_cloud_app()) { - if (duplicate_app->hybrid_app_preference() == - mobile_apis::HybridAppPreference::MOBILE) { - // Unregister cloud application and allow mobile application to register - // in it's place - application_manager_.UnregisterApplication( - duplicate_app->app_id(), mobile_apis::Result::USER_DISALLOWED); - error_response = false; - } + if (GetDuplicateNames(duplicate_apps)) { + LOG4CXX_ERROR(logger_, + "Found duplicate app names, checking for hybrid apps."); + // Default preference to BOTH + mobile_apis::HybridAppPreference::eType preference = + mobile_apis::HybridAppPreference::BOTH; + ApplicationSharedPtr app = + application_manager_.pending_application_by_policy_id(policy_app_id); + bool is_cloud_app = app.use_count() != 0 && app->is_cloud_app(); + if (is_cloud_app) { + // Retrieve hybrid app preference from registering app + preference = app->hybrid_app_preference(); } else { - ApplicationSharedPtr cloud_app = - application_manager_.pending_application_by_policy_id(policy_app_id); - // If the duplicate name was not because of a mobile/cloud app pair, go - // through the normal process for handling duplicate names - if (cloud_app.use_count() == 0 || !cloud_app->is_cloud_app()) { + if (mobile_apis::Result::DUPLICATE_NAME == coincidence_result) { usage_statistics::AppCounter count_of_rejections_duplicate_name( GetPolicyHandler().GetStatisticManager(), policy_app_id, usage_statistics::REJECTIONS_DUPLICATE_NAME); ++count_of_rejections_duplicate_name; - } else if (cloud_app->hybrid_app_preference() == - mobile_apis::HybridAppPreference::CLOUD) { - // Unregister mobile application and allow cloud application to - // register in it's place - application_manager_.UnregisterApplication( - duplicate_app->app_id(), mobile_apis::Result::USER_DISALLOWED); - error_response = false; + } + // Search for the hybrid app preference in the duplicate app list + for (auto duplicate_app : duplicate_apps) { + if (duplicate_app->is_cloud_app()) { + preference = duplicate_app->hybrid_app_preference(); + break; + } } } - if (error_response) { - LOG4CXX_ERROR(logger_, "Coincidence check failed."); - SendResponse(false, coincidence_result); - return; + if (preference == mobile_apis::HybridAppPreference::MOBILE || + preference == mobile_apis::HybridAppPreference::CLOUD) { + bool cloud_app_exists = is_cloud_app; + bool mobile_app_exists = !is_cloud_app; + for (auto duplicate_app : duplicate_apps) { + cloud_app_exists = cloud_app_exists || (duplicate_app->IsRegistered() && + duplicate_app->is_cloud_app()); + mobile_app_exists = mobile_app_exists || !duplicate_app->is_cloud_app(); + if (is_cloud_app && !duplicate_app->is_cloud_app() && + preference == mobile_apis::HybridAppPreference::CLOUD) { + // Unregister mobile application and allow cloud application to + // register in it's place + LOG4CXX_ERROR( + logger_, + "Unregistering app because a preferred version is registered."); + application_manager_.UnregisterApplication( + duplicate_app->app_id(), + mobile_apis::Result::USER_DISALLOWED, + "App is disabled by user preferences"); + } + } + + bool mobile_app_matches = + !is_cloud_app && + preference == mobile_apis::HybridAppPreference::MOBILE; + bool cloud_app_matches = + is_cloud_app && preference == mobile_apis::HybridAppPreference::CLOUD; + + bool is_preferred_application = mobile_app_matches || cloud_app_matches; + if (mobile_app_exists && cloud_app_exists && !is_preferred_application) { + SendResponse(false, + mobile_apis::Result::USER_DISALLOWED, + "App is disabled by user preferences"); + return; + } } - } else if (mobile_apis::Result::SUCCESS != coincidence_result) { + } + + if (mobile_apis::Result::SUCCESS != coincidence_result) { LOG4CXX_ERROR(logger_, "Coincidence check failed."); SendResponse(false, coincidence_result); return; @@ -458,6 +486,12 @@ void RegisterAppInterfaceRequest::Run() { } } + auto on_app_registered = [application](plugin_manager::RPCPlugin& plugin) { + plugin.OnApplicationEvent(plugin_manager::kApplicationRegistered, + application); + }; + application_manager_.ApplyFunctorForEachPlugin(on_app_registered); + if (msg_params.keyExists(strings::day_color_scheme)) { application->set_day_color_scheme(msg_params[strings::day_color_scheme]); } @@ -524,30 +558,30 @@ RegisterAppInterfaceRequest::GetLockScreenIconUrlNotification( void FillVRRelatedFields(smart_objects::SmartObject& response_params, const HMICapabilities& hmi_capabilities) { response_params[strings::language] = hmi_capabilities.active_vr_language(); - if (hmi_capabilities.vr_capabilities()) { - response_params[strings::vr_capabilities] = - *hmi_capabilities.vr_capabilities(); + auto vr_capabilities = hmi_capabilities.vr_capabilities(); + if (vr_capabilities) { + response_params[strings::vr_capabilities] = *vr_capabilities; } } void FillVIRelatedFields(smart_objects::SmartObject& response_params, const HMICapabilities& hmi_capabilities) { - if (hmi_capabilities.vehicle_type()) { - response_params[hmi_response::vehicle_type] = - *hmi_capabilities.vehicle_type(); + auto vehicle_type = hmi_capabilities.vehicle_type(); + if (vehicle_type) { + response_params[hmi_response::vehicle_type] = *vehicle_type; } } void FillTTSRelatedFields(smart_objects::SmartObject& response_params, const HMICapabilities& hmi_capabilities) { response_params[strings::language] = hmi_capabilities.active_tts_language(); - if (hmi_capabilities.speech_capabilities()) { - response_params[strings::speech_capabilities] = - *hmi_capabilities.speech_capabilities(); + auto speech_capabilities = hmi_capabilities.speech_capabilities(); + if (speech_capabilities) { + response_params[strings::speech_capabilities] = *speech_capabilities; } - if (hmi_capabilities.prerecorded_speech()) { - response_params[strings::prerecorded_speech] = - *(hmi_capabilities.prerecorded_speech()); + auto prerecorded_speech = hmi_capabilities.prerecorded_speech(); + if (prerecorded_speech) { + response_params[strings::prerecorded_speech] = *prerecorded_speech; } } @@ -555,82 +589,70 @@ void FillUIRelatedFields(smart_objects::SmartObject& response_params, const HMICapabilities& hmi_capabilities) { response_params[strings::hmi_display_language] = hmi_capabilities.active_ui_language(); - if (hmi_capabilities.display_capabilities()) { + + auto display_capabilities = hmi_capabilities.display_capabilities(); + if (display_capabilities) { response_params[hmi_response::display_capabilities] = smart_objects::SmartObject(smart_objects::SmartType_Map); smart_objects::SmartObject& display_caps = response_params[hmi_response::display_capabilities]; - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::display_type)) { + if (display_capabilities->keyExists(hmi_response::display_type)) { display_caps[hmi_response::display_type] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::display_type); + display_capabilities->getElement(hmi_response::display_type); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::display_name)) { + if (display_capabilities->keyExists(hmi_response::display_name)) { display_caps[hmi_response::display_name] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::display_name); + display_capabilities->getElement(hmi_response::display_name); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::text_fields)) { + if (display_capabilities->keyExists(hmi_response::text_fields)) { display_caps[hmi_response::text_fields] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::text_fields); + display_capabilities->getElement(hmi_response::text_fields); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::image_fields)) { + if (display_capabilities->keyExists(hmi_response::image_fields)) { display_caps[hmi_response::image_fields] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::image_fields); + display_capabilities->getElement(hmi_response::image_fields); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::media_clock_formats)) { + if (display_capabilities->keyExists(hmi_response::media_clock_formats)) { display_caps[hmi_response::media_clock_formats] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::media_clock_formats); + display_capabilities->getElement(hmi_response::media_clock_formats); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::templates_available)) { + if (display_capabilities->keyExists(hmi_response::templates_available)) { display_caps[hmi_response::templates_available] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::templates_available); + display_capabilities->getElement(hmi_response::templates_available); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::screen_params)) { + if (display_capabilities->keyExists(hmi_response::screen_params)) { display_caps[hmi_response::screen_params] = - hmi_capabilities.display_capabilities()->getElement( - hmi_response::screen_params); + display_capabilities->getElement(hmi_response::screen_params); } - if (hmi_capabilities.display_capabilities()->keyExists( + if (display_capabilities->keyExists( hmi_response::num_custom_presets_available)) { display_caps[hmi_response::num_custom_presets_available] = - hmi_capabilities.display_capabilities()->getElement( + display_capabilities->getElement( hmi_response::num_custom_presets_available); } - if (hmi_capabilities.display_capabilities()->keyExists( - hmi_response::image_capabilities)) { + if (display_capabilities->keyExists(hmi_response::image_capabilities)) { display_caps[hmi_response::graphic_supported] = - (hmi_capabilities.display_capabilities() - ->getElement(hmi_response::image_capabilities) + (display_capabilities->getElement(hmi_response::image_capabilities) .length() > 0); } } - if (hmi_capabilities.audio_pass_thru_capabilities()) { + auto audio_pass_thru_capabilities = + hmi_capabilities.audio_pass_thru_capabilities(); + if (audio_pass_thru_capabilities) { // hmi_capabilities json contains array and HMI response object response_params[strings::audio_pass_thru_capabilities] = - *hmi_capabilities.audio_pass_thru_capabilities(); + *audio_pass_thru_capabilities; } response_params[strings::hmi_capabilities] = smart_objects::SmartObject(smart_objects::SmartType_Map); @@ -728,36 +750,39 @@ void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile( FillVIRelatedFields(response_params, hmi_capabilities); } - if (hmi_capabilities.button_capabilities()) { - response_params[hmi_response::button_capabilities] = - *hmi_capabilities.button_capabilities(); + auto button_capabilities = hmi_capabilities.button_capabilities(); + if (button_capabilities) { + response_params[hmi_response::button_capabilities] = *button_capabilities; } - if (hmi_capabilities.soft_button_capabilities()) { + auto soft_button_capabilities = hmi_capabilities.soft_button_capabilities(); + if (soft_button_capabilities) { response_params[hmi_response::soft_button_capabilities] = - *hmi_capabilities.soft_button_capabilities(); + *soft_button_capabilities; } - if (hmi_capabilities.preset_bank_capabilities()) { + auto preset_bank_capabilities = hmi_capabilities.preset_bank_capabilities(); + if (preset_bank_capabilities) { response_params[hmi_response::preset_bank_capabilities] = - *hmi_capabilities.preset_bank_capabilities(); + *preset_bank_capabilities; } - if (hmi_capabilities.hmi_zone_capabilities()) { - if (smart_objects::SmartType_Array == - hmi_capabilities.hmi_zone_capabilities()->getType()) { + auto hmi_zone_capabilities = hmi_capabilities.hmi_zone_capabilities(); + if (hmi_zone_capabilities) { + if (smart_objects::SmartType_Array == hmi_zone_capabilities->getType()) { // hmi_capabilities json contains array and HMI response object response_params[hmi_response::hmi_zone_capabilities] = - *hmi_capabilities.hmi_zone_capabilities(); + *hmi_zone_capabilities; } else { response_params[hmi_response::hmi_zone_capabilities][0] = - *hmi_capabilities.hmi_zone_capabilities(); + *hmi_zone_capabilities; } } - if (hmi_capabilities.pcm_stream_capabilities()) { + auto pcm_stream_capabilities = hmi_capabilities.pcm_stream_capabilities(); + if (pcm_stream_capabilities) { response_params[strings::pcm_stream_capabilities] = - *hmi_capabilities.pcm_stream_capabilities(); + *pcm_stream_capabilities; } const std::vector<uint32_t>& diag_modes = @@ -875,6 +900,12 @@ void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile( // Default HMI level should be set before any permissions validation, since it // relies on HMI level. application_manager_.OnApplicationRegistered(application); + + auto send_rc_status = [application](plugin_manager::RPCPlugin& plugin) { + plugin.OnApplicationEvent(plugin_manager::kRCStatusChanged, application); + }; + application_manager_.ApplyFunctorForEachPlugin(send_rc_status); + SendOnAppRegisteredNotificationToHMI( application, resumption, need_restore_vr); (*notify_upd_manager)(); @@ -983,8 +1014,7 @@ void RegisterAppInterfaceRequest::SendOnAppRegisteredNotificationToHMI( DCHECK(rpc_service_.ManageHMICommand(notification)); } -mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckCoincidence( - std::vector<ApplicationSharedPtr>& out_duplicate_apps) { +mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckCoincidence() { LOG4CXX_AUTO_TRACE(logger_); const smart_objects::SmartObject& msg_params = (*message_)[strings::msg_params]; @@ -1008,8 +1038,7 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckCoincidence( const auto& cur_name = app->name(); if (app_name.CompareIgnoreCase(cur_name)) { LOG4CXX_ERROR(logger_, "Application name is known already."); - out_duplicate_apps.push_back(app); - continue; + return mobile_apis::Result::DUPLICATE_NAME; } const auto vr = app->vr_synonyms(); if (vr) { @@ -1018,8 +1047,7 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckCoincidence( if (0 != std::count_if(curr_vr->begin(), curr_vr->end(), v)) { LOG4CXX_ERROR(logger_, "Application name is known already."); - out_duplicate_apps.push_back(app); - continue; + return mobile_apis::Result::DUPLICATE_NAME; } } @@ -1030,8 +1058,7 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckCoincidence( CoincidencePredicateVR v(cur_name); if (0 != std::count_if(new_vr->begin(), new_vr->end(), v)) { LOG4CXX_ERROR(logger_, "vr_synonyms duplicated with app_name ."); - out_duplicate_apps.push_back(app); - continue; + return mobile_apis::Result::DUPLICATE_NAME; } } // End vr check @@ -1056,12 +1083,44 @@ mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckCoincidence( } // Application for end - if (!out_duplicate_apps.empty()) { - return mobile_apis::Result::DUPLICATE_NAME; - } return mobile_apis::Result::SUCCESS; } // method end +bool RegisterAppInterfaceRequest::GetDuplicateNames( + std::vector<ApplicationSharedPtr>& out_duplicate_apps) { + LOG4CXX_AUTO_TRACE(logger_); + const smart_objects::SmartObject& msg_params = + (*message_)[strings::msg_params]; + + const auto& app_name = msg_params[strings::app_name].asCustomString(); + { + const auto& accessor = application_manager_.applications().GetData(); + + for (const auto& app : accessor) { + const auto& cur_name = app->name(); + if (app_name.CompareIgnoreCase(cur_name)) { + out_duplicate_apps.push_back(app); + } + } + } + + const std::string policy_app_id = + application_manager_.GetCorrectMobileIDFromMessage(message_); + { + const auto& accessor = + application_manager_.pending_applications().GetData(); + + for (const auto& app : accessor) { + const auto& cur_name = app->name(); + if (app_name.CompareIgnoreCase(cur_name) && + policy_app_id != app->policy_app_id()) { + out_duplicate_apps.push_back(app); + } + } + } + return !out_duplicate_apps.empty(); +} + mobile_apis::Result::eType RegisterAppInterfaceRequest::CheckWithPolicyData() { LOG4CXX_AUTO_TRACE(logger_); // TODO(AOleynik): Check is necessary to allow register application in case |