summaryrefslogtreecommitdiff
path: root/src/components/policy/src/policy/src/policy_manager_impl.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/components/policy/src/policy/src/policy_manager_impl.cc')
-rw-r--r--src/components/policy/src/policy/src/policy_manager_impl.cc959
1 files changed, 0 insertions, 959 deletions
diff --git a/src/components/policy/src/policy/src/policy_manager_impl.cc b/src/components/policy/src/policy/src/policy_manager_impl.cc
deleted file mode 100644
index 0e73a465d8..0000000000
--- a/src/components/policy/src/policy/src/policy_manager_impl.cc
+++ /dev/null
@@ -1,959 +0,0 @@
-/*
- Copyright (c) 2016, Ford Motor Company
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-
- Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following
- disclaimer in the documentation and/or other materials provided with the
- distribution.
-
- Neither the name of the Ford Motor Company nor the names of its contributors
- may be used to endorse or promote products derived from this software
- without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
- */
-#include "policy/policy_manager_impl.h"
-
-#include <algorithm>
-#include <set>
-#include <queue>
-#include <iterator>
-#include "json/reader.h"
-#include "json/writer.h"
-#include "policy/policy_table.h"
-#include "policy/pt_representation.h"
-#include "policy/policy_helper.h"
-#include "utils/file_system.h"
-#include "utils/logger.h"
-#include "utils/date_time.h"
-#include "utils/make_shared.h"
-#include "policy/cache_manager.h"
-#include "policy/update_status_manager.h"
-#include "config_profile/profile.h"
-
-policy::PolicyManager *CreateManager() {
- return new policy::PolicyManagerImpl();
-}
-
-namespace {
-const uint32_t kDefaultRetryTimeoutInSec = 60u;
-} // namespace
-
-namespace policy {
-
-CREATE_LOGGERPTR_GLOBAL(logger_, "PolicyManagerImpl")
-
-PolicyManagerImpl::PolicyManagerImpl()
- : PolicyManager(), listener_(NULL), cache_(new CacheManager),
- retry_sequence_timeout_(kDefaultRetryTimeoutInSec),
- retry_sequence_index_(0),
- timer_retry_sequence_("Retry sequence timer", this,
- &PolicyManagerImpl::RetrySequence),
- ignition_check(true) {}
-
-void PolicyManagerImpl::set_listener(PolicyListener *listener) {
- listener_ = listener;
- update_status_manager_.set_listener(listener);
-}
-
-#ifdef USE_HMI_PTU_DECRYPTION
-
-utils::SharedPtr<policy_table::Table>
-PolicyManagerImpl::Parse(const BinaryMessage &pt_content) {
- std::string json(pt_content.begin(), pt_content.end());
- Json::Value value;
- Json::Reader reader;
- if (reader.parse(json.c_str(), value)) {
- return new policy_table::Table(&value);
- } else {
- return utils::SharedPtr<policy_table::Table>();
- }
-}
-
-#else
-
-utils::SharedPtr<policy_table::Table>
-PolicyManagerImpl::ParseArray(const BinaryMessage &pt_content) {
- std::string json(pt_content.begin(), pt_content.end());
- Json::Value value;
- Json::Reader reader;
- if (reader.parse(json.c_str(), value)) {
- // For PT Update received from SDL Server.
- if (value["data"].size() != 0) {
- Json::Value data = value["data"];
- // First Element in
- return new policy_table::Table(&data[0]);
- } else {
- return new policy_table::Table(&value);
- }
- } else {
- return utils::SharedPtr<policy_table::Table>();
- }
-}
-
-#endif
-
-void PolicyManagerImpl::CheckTriggers() {
- LOG4CXX_AUTO_TRACE(logger_);
- const bool exceed_ignition_cycles = ExceededIgnitionCycles();
- const bool exceed_days = ExceededDays();
-
- LOG4CXX_DEBUG(logger_, "\nDays exceeded: "
- << std::boolalpha << exceed_ignition_cycles
- << "\nStatusUpdateRequired: " << std::boolalpha
- << exceed_days);
-
- if (exceed_ignition_cycles || exceed_days) {
- update_status_manager_.ScheduleUpdate();
- }
-}
-
-bool PolicyManagerImpl::LoadPT(const std::string &file,
- const BinaryMessage &pt_content) {
- LOG4CXX_INFO(logger_, "LoadPT of size " << pt_content.size());
-
-#ifdef USE_HMI_PTU_DECRYPTION
- // Assuemes Policy Table was parsed, formatted, and/or decrypted by
- // the HMI after system request before calling OnReceivedPolicyUpdate
- // Parse message into table struct
- utils::SharedPtr<policy_table::Table> pt_update = Parse(pt_content);
-#else
- // Message Received from server unecnrypted with PTU in first element
- // of 'data' array. No Parsing was done by HMI.
- utils::SharedPtr<policy_table::Table> pt_update = ParseArray(pt_content);
-#endif
- if (!pt_update) {
- LOG4CXX_WARN(logger_, "Parsed table pointer is 0.");
- update_status_manager_.OnWrongUpdateReceived();
- return false;
- }
-
- if (!IsPTValid(pt_update, policy_table::PT_UPDATE)) {
- update_status_manager_.OnWrongUpdateReceived();
- return false;
- }
-
- update_status_manager_.OnValidUpdateReceived();
- cache_->SaveUpdateRequired(false);
-
- // Update finished, no need retry
- if (timer_retry_sequence_.isRunning()) {
- LOG4CXX_INFO(logger_, "Stop retry sequence");
- timer_retry_sequence_.stop();
- }
-
- apps_registration_lock_.Acquire();
-
- // Get current DB data, since it could be updated during awaiting of PTU
- utils::SharedPtr<policy_table::Table> policy_table_snapshot =
- cache_->GenerateSnapshot();
- if (!policy_table_snapshot) {
- LOG4CXX_ERROR(logger_, "Failed to create snapshot of policy table");
- return false;
- }
-
- // Checking of difference between PTU and current policy state
- // Must to be done before PTU applying since it is possible, that functional
- // groups, which had been present before are absent in PTU and will be
- // removed after update. So in case of revoked groups system has to know
- // names and ids of revoked groups before they will be removed.
- CheckPermissionsChanges(pt_update, policy_table_snapshot);
-
- // Replace current data with updated
- if (!cache_->ApplyUpdate(*pt_update)) {
- LOG4CXX_WARN(logger_, "Unsuccessful save of updated policy table.");
- return false;
- }
-
- std::map<std::string, StringArray> app_hmi_types;
- cache_->GetHMIAppTypeAfterUpdate(app_hmi_types);
- if (!app_hmi_types.empty()) {
- LOG4CXX_INFO(logger_, "app_hmi_types is full calling OnUpdateHMIAppType");
- listener_->OnUpdateHMIAppType(app_hmi_types);
- } else {
- LOG4CXX_INFO(logger_, "app_hmi_types empty" << pt_content.size());
- }
-
- apps_registration_lock_.Release();
-
- // If there was a user request for policy table update, it should be started
- // right after current update is finished
- if (update_status_manager_.IsUpdateRequired()) {
- StartPTExchange();
- return true;
- }
-
- RefreshRetrySequence();
- return true;
-}
-
-void PolicyManagerImpl::CheckPermissionsChanges(
- const utils::SharedPtr<policy_table::Table> pt_update,
- const utils::SharedPtr<policy_table::Table> snapshot) {
- LOG4CXX_INFO(logger_, "Checking incoming permissions.");
-
- // Replace predefined policies with its actual setting, e.g. "123":"default"
- // to actual values of default section
- UnwrapAppPolicies(pt_update->policy_table.app_policies_section.apps);
-
- std::for_each(pt_update->policy_table.app_policies_section.apps.begin(),
- pt_update->policy_table.app_policies_section.apps.end(),
- CheckAppPolicy(this, pt_update, snapshot));
-}
-
-void PolicyManagerImpl::PrepareNotificationData(
- const policy_table::FunctionalGroupings &groups,
- const policy_table::Strings &group_names,
- const std::vector<FunctionalGroupPermission> &group_permission,
- Permissions &notification_data) {
-
- LOG4CXX_INFO(logger_, "Preparing data for notification.");
- ProcessFunctionalGroup processor(groups, group_permission, notification_data);
- std::for_each(group_names.begin(), group_names.end(), processor);
-}
-
-void PolicyManagerImpl::GetServiceUrls(const std::string &service_type,
- EndpointUrls &end_points) {
- LOG4CXX_AUTO_TRACE(logger_);
- cache_->GetServiceUrls(service_type, end_points);
-}
-
-bool PolicyManagerImpl::RequestPTUpdate() {
- LOG4CXX_AUTO_TRACE(logger_);
- utils::SharedPtr<policy_table::Table> policy_table_snapshot =
- cache_->GenerateSnapshot();
- if (!policy_table_snapshot) {
- LOG4CXX_ERROR(logger_, "Failed to create snapshot of policy table");
- return false;
- }
-
- IsPTValid(policy_table_snapshot, policy_table::PT_SNAPSHOT);
-
- Json::Value value = policy_table_snapshot->ToJsonValue();
- Json::FastWriter writer;
- std::string message_string = writer.write(value);
-
- LOG4CXX_DEBUG(logger_, "Snapshot contents is : " << message_string);
-
- BinaryMessage update(message_string.begin(), message_string.end());
-
- listener_->OnSnapshotCreated(update);
-
- // Need to reset update schedule since all currenly registered applications
- // were already added to the snapshot so no update for them required.
- update_status_manager_.ResetUpdateSchedule();
-
- return true;
-}
-
-std::string PolicyManagerImpl::GetLockScreenIconUrl() const {
- return cache_->GetLockScreenIconUrl();
-}
-
-void PolicyManagerImpl::StartPTExchange() {
- LOG4CXX_AUTO_TRACE(logger_);
-
- const bool update_required = update_status_manager_.IsUpdateRequired();
-
- if (update_status_manager_.IsAppsSearchInProgress() && update_required) {
- update_status_manager_.ScheduleUpdate();
- LOG4CXX_INFO(logger_, "Starting exchange skipped, since applications "
- "search is in progress.");
- return;
- }
-
- if (update_status_manager_.IsUpdatePending() && update_required) {
- update_status_manager_.ScheduleUpdate();
- LOG4CXX_INFO(logger_, "Starting exchange skipped, since another exchange "
- "is in progress.");
- return;
- }
-
- if (listener_ && listener_->CanUpdate()) {
- if (ignition_check) {
- CheckTriggers();
- ignition_check = false;
- }
-
- if (update_required) {
- if (RequestPTUpdate() && !timer_retry_sequence_.isRunning()) {
- LOG4CXX_DEBUG(logger_, "Starting retry sequence.");
- timer_retry_sequence_.start(NextRetryTimeout());
- }
- }
- }
-}
-
-void PolicyManagerImpl::OnAppsSearchStarted() {
- LOG4CXX_AUTO_TRACE(logger_);
- update_status_manager_.OnAppsSearchStarted();
-}
-
-void PolicyManagerImpl::OnAppsSearchCompleted() {
- LOG4CXX_AUTO_TRACE(logger_);
- update_status_manager_.OnAppsSearchCompleted();
- if (update_status_manager_.IsUpdateRequired()) {
- StartPTExchange();
- }
-}
-
-void PolicyManagerImpl::OnAppRegisteredOnMobile(
- const std::string &application_id) {
- StartPTExchange();
- SendNotificationOnPermissionsUpdated(application_id);
-}
-
-const std::vector<std::string>
-PolicyManagerImpl::GetAppRequestTypes(const std::string policy_app_id) const {
- std::vector<std::string> request_types;
- cache_->GetAppRequestTypes(policy_app_id, request_types);
- return request_types;
-}
-void PolicyManagerImpl::CheckPermissions(const PTString &app_id,
- const PTString &hmi_level,
- const PTString &rpc,
- const RPCParams &rpc_params,
- CheckPermissionResult &result) {
- LOG4CXX_INFO(logger_, "CheckPermissions for " << app_id << " and rpc " << rpc
- << " for " << hmi_level
- << " level.");
-
- cache_->CheckPermissions(app_id, hmi_level, rpc, result);
-}
-
-bool PolicyManagerImpl::ResetUserConsent() {
- bool result = true;
-
- return result;
-}
-
-void PolicyManagerImpl::SendNotificationOnPermissionsUpdated(
- const std::string &application_id) {
- LOG4CXX_AUTO_TRACE(logger_);
- const std::string device_id = GetCurrentDeviceId(application_id);
- if (device_id.empty()) {
- LOG4CXX_WARN(logger_, "Couldn't find device info for application id "
- "'" << application_id << "'");
- return;
- }
-
- std::vector<FunctionalGroupPermission> app_group_permissions;
- GetPermissionsForApp(device_id, application_id, app_group_permissions);
-
- policy_table::FunctionalGroupings functional_groupings;
- cache_->GetFunctionalGroupings(functional_groupings);
-
- policy_table::Strings app_groups;
- std::vector<FunctionalGroupPermission>::const_iterator it =
- app_group_permissions.begin();
- std::vector<FunctionalGroupPermission>::const_iterator it_end =
- app_group_permissions.end();
- for (; it != it_end; ++it) {
- app_groups.push_back((*it).group_name);
- }
-
- Permissions notification_data;
- PrepareNotificationData(functional_groupings, app_groups,
- app_group_permissions, notification_data);
-
- LOG4CXX_INFO(logger_,
- "Send notification for application_id:" << application_id);
-
- std::string default_hmi;
- default_hmi = "NONE";
-
- listener()->OnPermissionsUpdated(application_id, notification_data,
- default_hmi);
-}
-
-bool PolicyManagerImpl::CleanupUnpairedDevices() {
- LOG4CXX_INFO(logger_, "CleanupUnpairedDevices");
- // For SDL-specific it doesn't matter
- return true;
-}
-
-DeviceConsent
-PolicyManagerImpl::GetUserConsentForDevice(const std::string &device_id) {
- LOG4CXX_AUTO_TRACE(logger_);
- return kDeviceAllowed;
-}
-
-void PolicyManagerImpl::SetUserConsentForDevice(const std::string &device_id,
- bool is_allowed) {
- LOG4CXX_INFO(logger_, "SetUserConsentForDevice");
- LOG4CXX_DEBUG(logger_, "Device :" << device_id);
- DeviceConsent current_consent = GetUserConsentForDevice(device_id);
- bool is_current_device_allowed =
- DeviceConsent::kDeviceAllowed == current_consent ? true : false;
- if (DeviceConsent::kDeviceHasNoConsent != current_consent &&
- is_current_device_allowed == is_allowed) {
- const std::string consent = is_allowed ? "allowed" : "disallowed";
- LOG4CXX_INFO(logger_, "Device is already " << consent << ".");
- return;
- }
-}
-
-bool PolicyManagerImpl::ReactOnUserDevConsentForApp(const std::string app_id,
- bool is_device_allowed) {
- return true;
-}
-
-bool PolicyManagerImpl::GetInitialAppData(const std::string &application_id,
- StringArray *nicknames,
- StringArray *app_hmi_types) {
- LOG4CXX_INFO(logger_, "GetInitialAppData");
- const bool result = nicknames && app_hmi_types;
- if (result) {
- cache_->GetInitialAppData(application_id, *nicknames, *app_hmi_types);
- }
- return result;
-}
-
-void PolicyManagerImpl::SetDeviceInfo(const std::string &device_id,
- const DeviceInfo &device_info) {
- LOG4CXX_INFO(logger_, "SetDeviceInfo");
- LOG4CXX_DEBUG(logger_, "Device :" << device_id);
-}
-
-PermissionConsent PolicyManagerImpl::EnsureCorrectPermissionConsent(
- const PermissionConsent &permissions_to_check) {
- std::vector<FunctionalGroupPermission> current_user_consents;
- GetUserConsentForApp(permissions_to_check.device_id,
- permissions_to_check.policy_app_id,
- current_user_consents);
-
- PermissionConsent permissions_to_set;
- permissions_to_set.device_id = permissions_to_check.device_id;
- permissions_to_set.policy_app_id = permissions_to_check.policy_app_id;
- permissions_to_set.consent_source = permissions_to_check.consent_source;
-
- std::vector<FunctionalGroupPermission>::const_iterator it =
- permissions_to_check.group_permissions.begin();
- std::vector<FunctionalGroupPermission>::const_iterator it_end =
- permissions_to_check.group_permissions.end();
-
- for (; it != it_end; ++it) {
- std::vector<FunctionalGroupPermission>::const_iterator it_curr =
- current_user_consents.begin();
- std::vector<FunctionalGroupPermission>::const_iterator it_curr_end =
- current_user_consents.end();
-
- for (; it_curr != it_curr_end; ++it_curr) {
- if (it->group_alias == it_curr->group_alias &&
- it->group_id == it_curr->group_id) {
- permissions_to_set.group_permissions.push_back(*it);
- }
- }
- }
-
- return permissions_to_set;
-}
-
-void PolicyManagerImpl::CheckPendingPermissionsChanges(
- const std::string &policy_app_id,
- const std::vector<FunctionalGroupPermission> &current_permissions) {
- LOG4CXX_INFO(logger_, "CheckPendingPermissionsChanges");
- sync_primitives::AutoLock lock(app_permissions_diff_lock_);
- std::map<std::string, AppPermissions>::iterator it_pending =
- app_permissions_diff_.find(policy_app_id);
- if (app_permissions_diff_.end() == it_pending) {
- LOG4CXX_WARN(logger_, "No pending permissions had been found for appID: "
- << policy_app_id);
- return;
- }
-
- LOG4CXX_DEBUG(logger_, "Pending permissions had been found for appID: "
- << policy_app_id);
-
- // Change appPermissionsConsentNeeded depending on unconsented groups
- // presence
- std::vector<policy::FunctionalGroupPermission>::const_iterator it_groups =
- current_permissions.begin();
- std::vector<policy::FunctionalGroupPermission>::const_iterator it_end_groups =
- current_permissions.end();
-
- for (; it_groups != it_end_groups; ++it_groups) {
- if (policy::kGroupUndefined == it_groups->state) {
- LOG4CXX_DEBUG(logger_, "Unconsented groups still present for appID: "
- << policy_app_id);
- it_pending->second.appPermissionsConsentNeeded = true;
- return;
- }
- }
-
- LOG4CXX_DEBUG(logger_, "Unconsented groups not present anymore for appID: "
- << policy_app_id);
- it_pending->second.appPermissionsConsentNeeded = false;
- return;
-}
-
-void PolicyManagerImpl::SetUserConsentForApp(
- const PermissionConsent &permissions) {
- LOG4CXX_INFO(logger_, "SetUserConsentForApp");
-}
-
-bool PolicyManagerImpl::GetDefaultHmi(const std::string &policy_app_id,
- std::string *default_hmi) {
- LOG4CXX_INFO(logger_, "GetDefaultHmi");
- return false;
-}
-
-bool PolicyManagerImpl::GetPriority(const std::string &policy_app_id,
- std::string *priority) {
- LOG4CXX_INFO(logger_, "GetPriority");
- if (!priority) {
- LOG4CXX_WARN(logger_, "Input priority parameter is null.");
- return false;
- }
-
- return cache_->GetPriority(policy_app_id, *priority);
-}
-
-std::vector<UserFriendlyMessage> PolicyManagerImpl::GetUserFriendlyMessages(
- const std::vector<std::string> &message_code, const std::string &language) {
- return cache_->GetUserFriendlyMsg(message_code, language);
-}
-
-void PolicyManagerImpl::GetUserConsentForApp(
- const std::string &device_id, const std::string &policy_app_id,
- std::vector<FunctionalGroupPermission> &permissions) {
- LOG4CXX_INFO(logger_, "GetUserConsentForApp");
-
- FunctionalIdType group_types;
- if (!cache_->GetPermissionsForApp(device_id, policy_app_id, group_types)) {
- LOG4CXX_WARN(logger_, "Can't get user permissions for app "
- << policy_app_id);
- return;
- }
-
- // Functional groups w/o alias ("user_consent_prompt") considered as
- // automatically allowed and it could not be changed by user
- FunctionalGroupNames group_names;
- if (!cache_->GetFunctionalGroupNames(group_names)) {
- LOG4CXX_WARN(logger_, "Can't get functional group names");
- return;
- }
-
- FunctionalGroupNames::const_iterator it = group_names.begin();
- FunctionalGroupNames::const_iterator it_end = group_names.end();
- FunctionalGroupIDs auto_allowed_groups;
- for (; it != it_end; ++it) {
- if (it->second.first.empty()) {
- auto_allowed_groups.push_back(it->first);
- }
- }
-
- // For basic policy
- FunctionalGroupIDs all_groups = group_types[kTypeGeneral];
- FunctionalGroupIDs default_groups = group_types[kTypeDefault];
- FunctionalGroupIDs predataconsented_groups =
- group_types[kTypePreDataConsented];
-
- FunctionalGroupIDs allowed_groups;
- FunctionalGroupIDs no_auto = ExcludeSame(all_groups, auto_allowed_groups);
-
- if (cache_->IsDefaultPolicy(policy_app_id)) {
- allowed_groups = ExcludeSame(no_auto, default_groups);
- } else if (cache_->IsPredataPolicy(policy_app_id)) {
- allowed_groups = ExcludeSame(no_auto, predataconsented_groups);
- }
- FillFunctionalGroupPermissions(allowed_groups, group_names, kGroupAllowed,
- permissions);
-}
-
-void PolicyManagerImpl::GetPermissionsForApp(
- const std::string &device_id, const std::string &policy_app_id,
- std::vector<FunctionalGroupPermission> &permissions) {
- LOG4CXX_INFO(logger_, "GetPermissionsForApp");
- std::string app_id_to_check = policy_app_id;
-
- bool allowed_by_default = false;
- if (cache_->IsDefaultPolicy(policy_app_id)) {
- app_id_to_check = kDefaultId;
- allowed_by_default = true;
- } else if (cache_->IsPredataPolicy(policy_app_id) ||
- policy::kDeviceDisallowed == GetUserConsentForDevice(device_id)) {
- app_id_to_check = kPreDataConsentId;
- allowed_by_default = true;
- }
-
- FunctionalIdType group_types;
- if (!cache_->GetPermissionsForApp(device_id, app_id_to_check, group_types)) {
- LOG4CXX_WARN(logger_, "Can't get user permissions for app "
- << policy_app_id);
- return;
- }
-
- // Functional groups w/o alias ("user_consent_prompt") considered as
- // automatically allowed and it could not be changed by user
- FunctionalGroupNames group_names;
- if (!cache_->GetFunctionalGroupNames(group_names)) {
- LOG4CXX_WARN(logger_, "Can't get functional group names");
- return;
- }
-
- // The "default" and "pre_DataConsent" are auto-allowed groups
- // So, check if application in the one of these mode.
- if (allowed_by_default) {
- LOG4CXX_INFO(logger_, "Get auto allowed groups");
- GroupType type =
- (kDefaultId == app_id_to_check ? kTypeDefault : kTypePreDataConsented);
-
- FillFunctionalGroupPermissions(group_types[type], group_names,
- kGroupAllowed, permissions);
- } else {
-
- // The code bellow allows to process application which
- // has specific permissions(not default and pre_DataConsent).
-
- // All groups for specific application
- FunctionalGroupIDs all_groups = group_types[kTypeGeneral];
-
- // In case of GENIVI all groups are allowed
- FunctionalGroupIDs common_allowed = all_groups;
- FillFunctionalGroupPermissions(common_allowed, group_names, kGroupAllowed,
- permissions);
- }
- return;
-}
-
-std::string &
-PolicyManagerImpl::GetCurrentDeviceId(const std::string &policy_app_id) {
- LOG4CXX_INFO(logger_, "GetDeviceInfo");
- last_device_id_ = listener()->OnCurrentDeviceIdUpdateRequired(policy_app_id);
- return last_device_id_;
-}
-
-void PolicyManagerImpl::SetSystemLanguage(const std::string &language) {}
-
-void PolicyManagerImpl::SetSystemInfo(const std::string &ccpu_version,
- const std::string &wers_country_code,
- const std::string &language) {
- LOG4CXX_INFO(logger_, "SetSystemInfo");
-}
-
-void PolicyManagerImpl::OnSystemReady() {
- // Update policy table for the first time with system information
- if (cache_->IsPTPreloaded()) {
- listener()->OnSystemInfoUpdateRequired();
- return;
- }
-}
-
-uint32_t
-PolicyManagerImpl::GetNotificationsNumber(const std::string &priority) {
- LOG4CXX_INFO(logger_, "GetNotificationsNumber");
- return cache_->GetNotificationsNumber(priority);
-}
-
-bool PolicyManagerImpl::ExceededIgnitionCycles() {
- return 0 == cache_->IgnitionCyclesBeforeExchange();
-}
-
-bool PolicyManagerImpl::IsPTValid(
- utils::SharedPtr<policy_table::Table> policy_table,
- policy_table::PolicyTableType type) const {
- policy_table->SetPolicyTableType(type);
- if (!policy_table->is_valid()) {
- LOG4CXX_ERROR(logger_, "Policy table is not valid.");
- rpc::ValidationReport report("policy_table");
- policy_table->ReportErrors(&report);
- LOG4CXX_DEBUG(logger_, "Errors: " << rpc::PrettyFormat(report));
- return false;
- }
- return true;
-}
-
-bool PolicyManagerImpl::ExceededDays() {
-
- TimevalStruct current_time = date_time::DateTime::getCurrentTime();
- const int kSecondsInDay = 60 * 60 * 24;
- int days = current_time.tv_sec / kSecondsInDay;
-
- return 0 == cache_->DaysBeforeExchange(days);
-}
-
-void PolicyManagerImpl::KmsChanged(int kilometers) {
- LOG4CXX_AUTO_TRACE(logger_);
- if (0 == cache_->KilometersBeforeExchange(kilometers)) {
- LOG4CXX_INFO(logger_, "Enough kilometers passed to send for PT update.");
- update_status_manager_.ScheduleUpdate();
- StartPTExchange();
- }
-}
-
-void PolicyManagerImpl::IncrementIgnitionCycles() {
- cache_->IncrementIgnitionCycles();
-}
-
-std::string PolicyManagerImpl::ForcePTExchange() {
- update_status_manager_.ScheduleUpdate();
- StartPTExchange();
- return update_status_manager_.StringifiedUpdateStatus();
-}
-
-std::string PolicyManagerImpl::GetPolicyTableStatus() const {
- return update_status_manager_.StringifiedUpdateStatus();
-}
-
-uint32_t PolicyManagerImpl::NextRetryTimeout() {
- sync_primitives::AutoLock auto_lock(retry_sequence_lock_);
- LOG4CXX_DEBUG(logger_, "Index: " << retry_sequence_index_);
- uint32_t next = 0u;
- if (retry_sequence_seconds_.empty() ||
- retry_sequence_index_ >= retry_sequence_seconds_.size()) {
- LOG4CXX_WARN(logger_, "Next retry timeout is " << next);
- return next;
- }
-
- ++retry_sequence_index_;
-
- for (uint32_t i = 0u; i < retry_sequence_index_; ++i) {
- next += retry_sequence_seconds_[i];
- LOG4CXX_DEBUG(logger_, "Next retry timeout to add is " << next);
- // According to requirement APPLINK-18244
- }
- next += retry_sequence_timeout_;
- LOG4CXX_DEBUG(logger_, "Total retry timeout is " << next);
- return next;
-}
-
-void PolicyManagerImpl::RefreshRetrySequence() {
- sync_primitives::AutoLock auto_lock(retry_sequence_lock_);
- retry_sequence_timeout_ = cache_->TimeoutResponse();
- retry_sequence_seconds_.clear();
- cache_->SecondsBetweenRetries(retry_sequence_seconds_);
-}
-
-void PolicyManagerImpl::ResetRetrySequence() {
- sync_primitives::AutoLock auto_lock(retry_sequence_lock_);
- retry_sequence_index_ = 0;
- update_status_manager_.OnResetRetrySequence();
-}
-
-int PolicyManagerImpl::TimeoutExchange() { return retry_sequence_timeout_; }
-
-const std::vector<int> PolicyManagerImpl::RetrySequenceDelaysSeconds() {
- sync_primitives::AutoLock auto_lock(retry_sequence_lock_);
- return retry_sequence_seconds_;
-}
-
-void PolicyManagerImpl::OnExceededTimeout() {
- update_status_manager_.OnUpdateTimeoutOccurs();
-}
-
-void PolicyManagerImpl::OnUpdateStarted() {
- int update_timeout = TimeoutExchange();
- LOG4CXX_INFO(logger_, "Update timeout will be set to: " << update_timeout);
- update_status_manager_.OnUpdateSentOut(update_timeout);
- cache_->SaveUpdateRequired(true);
-}
-
-void PolicyManagerImpl::PTUpdatedAt(int kilometers, int days_after_epoch) {
- LOG4CXX_INFO(logger_, "PTUpdatedAt");
- LOG4CXX_INFO(logger_, "Kilometers: " << kilometers
- << " Days: " << days_after_epoch);
- cache_->SetCountersPassedForSuccessfulUpdate(kilometers, days_after_epoch);
- cache_->ResetIgnitionCycles();
-}
-
-void PolicyManagerImpl::Increment(usage_statistics::GlobalCounterId type) {
- LOG4CXX_INFO(logger_, "Increment without app id");
- sync_primitives::AutoLock locker(statistics_lock_);
-}
-
-void PolicyManagerImpl::Increment(const std::string &app_id,
- usage_statistics::AppCounterId type) {
- LOG4CXX_INFO(logger_, "Increment " << app_id);
- sync_primitives::AutoLock locker(statistics_lock_);
-}
-
-void PolicyManagerImpl::Set(const std::string &app_id,
- usage_statistics::AppInfoId type,
- const std::string &value) {
- LOG4CXX_INFO(logger_, "Set " << app_id);
- sync_primitives::AutoLock locker(statistics_lock_);
-}
-
-void PolicyManagerImpl::Add(const std::string &app_id,
- usage_statistics::AppStopwatchId type,
- int32_t timespan_seconds) {
- LOG4CXX_INFO(logger_, "Add " << app_id);
- sync_primitives::AutoLock locker(statistics_lock_);
-}
-
-bool PolicyManagerImpl::IsApplicationRevoked(const std::string &app_id) const {
- return cache_->IsApplicationRevoked(app_id);
-}
-
-bool PolicyManagerImpl::IsConsentNeeded(const std::string &app_id) {
- LOG4CXX_AUTO_TRACE(logger_);
- return false;
-}
-
-void PolicyManagerImpl::SetVINValue(const std::string &value) {}
-
-AppPermissions
-PolicyManagerImpl::GetAppPermissionsChanges(const std::string &policy_app_id) {
- typedef std::map<std::string, AppPermissions>::iterator PermissionsIt;
- PermissionsIt app_id_diff = app_permissions_diff_.find(policy_app_id);
- AppPermissions permissions(policy_app_id);
- if (app_permissions_diff_.end() != app_id_diff) {
- permissions = app_id_diff->second;
- } else {
- permissions.appPermissionsConsentNeeded = IsConsentNeeded(policy_app_id);
- permissions.appRevoked = IsApplicationRevoked(policy_app_id);
- GetPriority(permissions.application_id, &permissions.priority);
- }
- return permissions;
-}
-
-void PolicyManagerImpl::RemovePendingPermissionChanges(
- const std::string &app_id) {
- app_permissions_diff_.erase(app_id);
-}
-
-bool PolicyManagerImpl::CanAppKeepContext(const std::string &app_id) {
- return cache_->CanAppKeepContext(app_id);
-}
-
-bool PolicyManagerImpl::CanAppStealFocus(const std::string &app_id) {
- return cache_->CanAppStealFocus(app_id);
-}
-
-void PolicyManagerImpl::MarkUnpairedDevice(const std::string &device_id) {}
-
-void PolicyManagerImpl::AddApplication(const std::string &application_id) {
- LOG4CXX_INFO(logger_, "AddApplication");
- const std::string device_id = GetCurrentDeviceId(application_id);
- DeviceConsent device_consent = GetUserConsentForDevice(device_id);
- sync_primitives::AutoLock lock(apps_registration_lock_);
-
- if (IsNewApplication(application_id)) {
- AddNewApplication(application_id, device_consent);
- update_status_manager_.OnNewApplicationAdded();
- } else {
- PromoteExistedApplication(application_id, device_consent);
- }
-}
-
-void PolicyManagerImpl::RemoveAppConsentForGroup(
- const std::string &app_id, const std::string &group_name) {
- cache_->RemoveAppConsentForGroup(app_id, group_name);
-}
-
-bool PolicyManagerImpl::IsPredataPolicy(const std::string &policy_app_id) {
- LOG4CXX_INFO(logger_, "IsPredataApp");
- return cache_->IsPredataPolicy(policy_app_id);
-}
-
-void PolicyManagerImpl::AddNewApplication(const std::string &application_id,
- DeviceConsent device_consent) {
- LOG4CXX_AUTO_TRACE(logger_);
-
- cache_->SetDefaultPolicy(application_id);
-}
-
-void PolicyManagerImpl::PromoteExistedApplication(
- const std::string &application_id, DeviceConsent device_consent) {
- // If device consent changed to allowed during application being
- // disconnected, app permissions should be changed also
- if (kDeviceAllowed == device_consent &&
- cache_->IsPredataPolicy(application_id)) {
- cache_->SetDefaultPolicy(application_id);
- }
-}
-
-bool PolicyManagerImpl::IsNewApplication(
- const std::string &application_id) const {
- return false == cache_->IsApplicationRepresented(application_id);
-}
-
-bool PolicyManagerImpl::ResetPT(const std::string &file_name) {
- cache_->ResetCalculatedPermissions();
- const bool result = cache_->ResetPT(file_name);
- if (result) {
- RefreshRetrySequence();
- }
- return result;
-}
-
-bool PolicyManagerImpl::CheckAppStorageFolder() const {
- LOG4CXX_AUTO_TRACE(logger_);
- const std::string app_storage_folder =
- profile::Profile::instance()->app_storage_folder();
- LOG4CXX_DEBUG(logger_, "AppStorageFolder " << app_storage_folder);
- if (!file_system::DirectoryExists(app_storage_folder)) {
- LOG4CXX_WARN(logger_, "Storage directory doesn't exist "
- << app_storage_folder);
- return false;
- }
- if (!(file_system::IsWritingAllowed(app_storage_folder) &&
- file_system::IsReadingAllowed(app_storage_folder))) {
- LOG4CXX_WARN(logger_,
- "Storage directory doesn't have read/write permissions "
- << app_storage_folder);
- return false;
- }
- return true;
-}
-
-bool PolicyManagerImpl::InitPT(const std::string &file_name) {
- LOG4CXX_AUTO_TRACE(logger_);
- if (!CheckAppStorageFolder()) {
- LOG4CXX_ERROR(logger_, "Can not read/write into AppStorageFolder");
- return false;
- }
- const bool ret = cache_->Init(file_name);
- if (ret) {
- RefreshRetrySequence();
- update_status_manager_.OnPolicyInit(cache_->UpdateRequired());
- }
- return ret;
-}
-
-uint16_t PolicyManagerImpl::HeartBeatTimeout(const std::string &app_id) const {
- return cache_->HeartBeatTimeout(app_id);
-}
-
-void PolicyManagerImpl::SaveUpdateStatusRequired(bool is_update_needed) {
- cache_->SaveUpdateRequired(is_update_needed);
-}
-
-void PolicyManagerImpl::set_cache_manager(
- CacheManagerInterface *cache_manager) {
- cache_ = cache_manager;
-}
-
-void PolicyManagerImpl::RetrySequence() {
- LOG4CXX_INFO(logger_, "Start new retry sequence");
- RequestPTUpdate();
-
- uint32_t timeout = NextRetryTimeout();
-
- if (!timeout && timer_retry_sequence_.isRunning()) {
- timer_retry_sequence_.stop();
- return;
- }
-
- timer_retry_sequence_.start(timeout);
-}
-
-} // namespace policy
View Lorry Controller Status