+++ /dev/null
-/*! \page components_appmgr App Manager
-
-Here will be information about App Manager component
-
-*/
\ No newline at end of file
+++ /dev/null
-/*! \page components_hmi HMI
-
-Here will be information about HMI component
-
-*/
\ No newline at end of file
+++ /dev/null
-/*! \page components_protocolhandler Protocol Handler
-
-Here will be information about Protocol Handler component
-
-*/
\ No newline at end of file
+++ /dev/null
-/** @page components_transportmanager_client_connection_management Connection Management
- *
- * As all requests to TransportManager are asynchronous, client must implement NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener
- * interface and add itself as a device listener with NsSmartDeviceLink::NsTransportManager::ITransportManager::addDeviceListener()
- * in order to receive notifications.
- * To connect remote device client must use NsSmartDeviceLink::NsTransportManager::ITransportManager::connectDevice(). It will initiate connections to all
- * applications running on remove device. For TCP device this call has no effect as TCP connections are initiated by remote devices.
- * Client will be notified about each connected application with NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener::onApplicationConnected().
- * To disconnect all applications running on remote device client must use NsSmartDeviceLink::NsTransportManager::ITransportManager::disconnectDevice().
- * Client will be notified about each disconnected application with NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener::onApplicationDisconnected().
- */
+++ /dev/null
-/** @page components_transportmanager_client_data_transfer Data Transfer
- *
- * As all requests to TransportManager are asynchronous, client must implement NsSmartDeviceLink::NsTransportManager::ITransportManagerDataListener
- * interface and add itself as a data listener with NsSmartDeviceLink::NsTransportManager::ITransportManager::addDataListener()
- * in order to receive notifications.
- * To send frame to remote device client must use NsSmartDeviceLink::NsTransportManager::ITransportManager::sendFrame() poviding connection handle,
- * frame data, data size and user data. User data is an integer that is assigned to a frame and will be sent back to client when sending of frame
- * will be completed. Client may use this data to identify frame when send result will be reported. When sending of frame is completed
- * client is notified via NsSmartDeviceLink::NsTransportManager::ITransportManagerDataListener::onFrameSendCompleted(). When frame is received from a remote
- * device client is notified via NsSmartDeviceLink::NsTransportManager::ITransportManagerDataListener::onFrameReceived().
- */
+++ /dev/null
-/** @page components_transportmanager_client_device_management Device Management
- *
- * As all requests to TransportManager are asynchronous, client must implement NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener
- * interface and add itself as a device listener with NsSmartDeviceLink::NsTransportManager::ITransportManager::addDeviceListener()
- * in order to receive notifications.
- * Client of TransportManager may use NsSmartDeviceLink::NsTransportManager::ITransportManager::scanForNewDevices()
- * to initiate device scan on all device adapters that support this feature. In order to get list of available
- * devices client must override NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener::onDeviceListUpdated().
- * Each device adapter will perform scan independently from other device adapters and device list might be updated
- * several times (after each adapter that supports scanning finishes scanning operation). Device list might also be
- * updated without device scan request, e.g. if new client connects via TCP this device will be added to device list
- * and update notification will be sent to client. In any of these cases client will be provided with the full
- * device list from all device adapters in every notification.
- */
+++ /dev/null
-/*! \page components_transportmanager_client Transport Manager Client Specification
-
-This chapter describes details of correct use of Transport Manager on the client side. In other words this chapter can be called "How to create effective and safe client of Transport Manager".
-Transport Manager defines set of asynchronous requests (means that operations are non-blocking in the calling thread) and provides two different interfaces to monitor asynchronous responses and notifications about data update.
-
-Clients of Transport Manager should use NsSmartDeviceLink::NsTransportManager::ITransportManager interface to initiate any request to the component.
-Also Transport Manager provides two different interfaces:
-
-1) NsSmartDeviceLink::NsTransportManager::ITransportManagerDataListener. Client can implement this interface if it needs information about data frame send/receive.
-
-2) NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener. Client can implement this interface if it needs information about updates of devices available for communication and current client applications status.
-
-For more information about typical use of Transport Manager please read the following topics:
- - \subpage components_transportmanager_client_device_management "Device Management"
- - \subpage components_transportmanager_client_connection_management "Connection Management"
- - \subpage components_transportmanager_client_data_transfer "Data Transfer"
-
-*/
+++ /dev/null
-/*! \page components_transportmanager_internal_design_interaction Sub-Components Interaction
-
-Internally Transport Manager is a root component for Device Adapters. After running Transport Manager creates Device Adapters and runs them too.
-
-During system life cycle all messages from Device Adapter are translated via Transport Manager to the clients. In other direction – all requests from clients are re-directed to respective Device Adapters by the Transport Manager.
-
-*/
+++ /dev/null
-/*! \page components_transportmanager_internal_design_multithreading Multi-Threading in Component
-
-Internally Transport Manager uses different threads for different operations. This design solution was used to provide efficient asynchronous communication with clients and underlying Device Adapters.
-
-Transport Manager uses one thread to operate with all device-related callbacks. In other word all callbacks declared in NsSmartDeviceLink::NsTransportManager::ITransportManagerDeviceListener will be called from that thread.
-
-For every active connection one service thread will be created. This thread will be used for all connection-related callbacks. Therefore every implementation of NsSmartDeviceLink::NsTransportManager::ITransportManagerDataListener will be called in separated thread that allows client to support multiple connection simultaneously.
-
-*/
+++ /dev/null
-/*! \page components_transportmanager_internal_design_trasport_manager Trasport Manager Implementation
-
-Actually Transport Manager component is implemented as classical manager component. It manages connections and abstract devices and provides unified information for the clients.
-
-Connection-related information encapsulated in structure NsSmartDeviceLink::NsTransportManager::CTransportManager::SConnectionInfo. Transport Manager manages these structures to store information about every active connection.
-
-Frame processing encapsulated in structure NsSmartDeviceLink::NsTransportManager::CTransportManager::SFrameDataForConnection. Transport Manager manages these structures to store information related to data for specific connection.
-
-Callback information between transport manager threads passed in form of special structures:
-NsSmartDeviceLink::NsTransportManager::CTransportManager::SDeviceListenerCallback.
-NsSmartDeviceLink::NsTransportManager::CTransportManager::SDataListenerCallback.
-
-Client calls to TM guarded by separate mutex. This allows use component from different threads without any risk.
-
-*/
+++ /dev/null
-/*! \page components_transportmanager Transport Manager
-
-Transport Manager is a component of SmartDeviceLink application which is designed to provide transparent access to transport layer for other components. Current implementation provides unified access to connections via Bluetooth and TCP. Also this component allows run automatic device discovery and provides information about found devices which is able to connect to SmartDeviceLink.
-
-More detailed information is described in following chapters:
- - \subpage components_transportmanager_client "Transport Manager Client Specification"
- - \subpage components_transportmanager_internal_design "Component Internal Design"
- - \subpage components_transportmanager_use_cases "High-Level Use Cases to Test Component"
-*/
+++ /dev/null
-/*! \page info Project information
-
-Here will be general information about project
-
-*/
\ No newline at end of file
+++ /dev/null
-# source filename
-regexp=\w+\.(?:cpp|h)
-colours=yellow
-===
-regexp=^(ERROR|FATAL)
-colours=red on_yellow
-===
-regexp=^WARN
-colours=red
-===
-regexp=^INFO
-colours=blue
-===
-regexp=^TRACE
-colours=magenta
-===
-# component
-regexp=(?<=\])\[[^]]+\]
-colours=cyan
-===
-# something invalid
-regexp=(?i)invalid
-colours=red
-===
-# RPC message start
-regexp=^\{$
-colours=bold
-count=block
-===
-# RPC message end
-regexp=^\}$
-colours=bold
-count=unblock
-
+++ /dev/null
-# smartDeviceCore command
-(^|[/\w\.]+/)smartDeviceLinkCore\s?
-conf.smartDeviceLinkCore
endif()
#Generation of policy table interface...
-include(${CMAKE_SOURCE_DIR}/tools/intergen/GenerateInterfaceLibrary.cmake)
-
-if (EXTENDED_POLICY_FLAG)
- GenerateInterfaceLibrary("policy_table_interface_ext.xml" policy_table_interface_base)
-else ()
- GenerateInterfaceLibrary("policy_table_interface.xml" policy_table_interface_base)
-endif()
+#include(${CMAKE_SOURCE_DIR}/tools/intergen/GenerateInterfaceLibrary.cmake)
include_directories (
./include
./usage_statistics/include
${CMAKE_SOURCE_DIR}/src/components/rpc_base/include
- ${CMAKE_CURRENT_BINARY_DIR}
+ ${CMAKE_SOURCE_DIR}/src/thirdPartyLibs/jsoncpp/include
+ #${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_SOURCE_DIR}/src/components/utils/include/
${CMAKE_SOURCE_DIR}/src/components/config_profile/include
)
set(SOURCES
./src/policy_manager_impl.cc
./src/policy_helper.cc
- ./src/syncp_adapter.cc
./src/policy_table.cc
./src/sql_pt_queries.cc
./src/sql_pt_representation.cc
add_subdirectory(usage_statistics)
+if (EXTENDED_POLICY_FLAG)
+add_subdirectory(policy_table/table_struct_ext)
+include_directories(./policy_table/table_struct_ext)
+else ()
+include_directories(./policy_table/table_struct)
+add_subdirectory(policy_table/table_struct)
+endif()
+
+set(LIBRARIES ConfigProfile policy_struct dbms jsoncpp Utils)
if (CMAKE_SYSTEM_NAME STREQUAL "QNX")
# --- QDB Wrapper
include_directories (qdb_wrapper/include)
# --- SQLite Wrapper
include_directories (sqlite_wrapper/include)
add_subdirectory(sqlite_wrapper)
+ list(APPEND LIBRARIES sqlite3)
endif ()
-set(LIBRARIES ConfigProfile dbms policy_table_interface_base)
-
add_library(${target} SHARED ${SOURCES})
-target_link_libraries(${target} ${LIBRARIES})
+target_link_libraries(${target} ${LIBRARIES} )
if(ENABLE_LOG)
add_dependencies(${target} liblog4cxx)
#ifndef SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_HELPER_H_
#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_HELPER_H_
-#include "policy_table_interface_base/functions.h"
+#include "./functions.h"
#include "utils/shared_ptr.h"
#include "policy/policy_types.h"
* @brief Helper struct to compare functional group names
*/
struct CompareGroupName {
- explicit CompareGroupName(const StringsValueType& group_name);
- bool operator()(const StringsValueType& group_name_to_compare) const;
- private:
- const StringsValueType& group_name_;
+ explicit CompareGroupName(const StringsValueType& group_name);
+ bool operator()(const StringsValueType& group_name_to_compare) const;
+ private:
+ const StringsValueType& group_name_;
};
/*
* updated and notification will be sent to application
*/
struct CheckAppPolicy {
- CheckAppPolicy(PolicyManagerImpl* pm,
- const utils::SharedPtr<policy_table::Table> update);
- bool HasSameGroups(const AppPoliciesValueType& app_policy,
- AppPermissions* perms) const;
- bool IsNewAppication(const std::string& application_id) const;
- void SendNotification(const AppPoliciesValueType& app_policy) const;
- void SendOnPendingPermissions(const AppPoliciesValueType& app_policy,
- AppPermissions permissions) const;
- bool IsAppRevoked(const AppPoliciesValueType& app_policy) const;
- bool NicknamesMatch(const std::string app_id,
+ CheckAppPolicy(PolicyManagerImpl* pm,
+
const utils::SharedPtr<policy_table::Table> update);
+ bool HasSameGroups(const AppPoliciesValueType& app_policy,
+ AppPermissions* perms) const;
+ bool IsNewAppication(const std::string& application_id) const;
+ void SendNotification(const AppPoliciesValueType& app_policy) const;
+ void SendOnPendingPermissions(const AppPoliciesValueType& app_policy,
+ AppPermissions permissions) const;
+ bool IsAppRevoked(const AppPoliciesValueType& app_policy) const;
+ bool NicknamesMatch(const std::string app_id,
const AppPoliciesValueType& app_policy) const;
- bool operator()(const AppPoliciesValueType& app_policy);
- private:
- PolicyManagerImpl* pm_;
- const utils::SharedPtr<policy_table::Table> update_;
+ bool operator()(const AppPoliciesValueType& app_policy);
+ private:
+ PolicyManagerImpl* pm_;
+
const utils::SharedPtr<policy_table::Table> update_;
};
/*
* parameters
*/
struct FillNotificationData {
- FillNotificationData(Permissions& data, GroupConsent group_state);
- bool operator()(const RpcValueType& rpc);
- void UpdateHMILevels(const policy_table::HmiLevels& in_hmi,
- std::set<HMILevel>& out_hmi);
- void UpdateParameters(const policy_table::Parameters& in_parameters,
- std::set<Parameter>& out_parameter);
- private:
- void ExcludeDisAllowed();
- std::string current_key_;
- Permissions& data_;
+ FillNotificationData(Permissions& data, GroupConsent group_state);
+ bool operator()(const RpcValueType& rpc);
+ void UpdateHMILevels(const policy_table::HmiLevels& in_hmi,
+ std::set<HMILevel>& out_hmi);
+ void UpdateParameters(const policy_table::Parameters& in_parameters,
+
std::set<Parameter>& out_parameter);
+ private:
+ void ExcludeDisAllowed();
+ std::string current_key_;
+ Permissions& data_;
};
/*
* which gather data for notification sending
*/
struct ProcessFunctionalGroup {
- ProcessFunctionalGroup(
+ ProcessFunctionalGroup(
const policy_table::FunctionalGroupings& fg,
const std::vector<FunctionalGroupPermission>& group_permissions,
Permissions& data);
- bool operator()(const StringsValueType& group_name);
- private:
- GroupConsent GetGroupState(const std::string& group_name);
- const policy_table::FunctionalGroupings& fg_;
- Permissions& data_;
- const std::vector<FunctionalGroupPermission>& group_permissions_;
+ bool operator()(const StringsValueType& group_name);
+ private:
+ GroupConsent GetGroupState(const std::string& group_name);
+ const policy_table::FunctionalGroupings& fg_;
+ Permissions& data_;
+ const std::vector<FunctionalGroupPermission>& group_permissions_;
};
struct FunctionalGroupInserter {
- FunctionalGroupInserter(const policy_table::Strings& preconsented_groups,
- PermissionsList& list);
- void operator()(const StringsValueType& group_name);
- private:
- PermissionsList& list_;
- const policy_table::Strings& preconsented_;
+ FunctionalGroupInserter(const policy_table::Strings& preconsented_groups,
+ PermissionsList& list);
+ void operator()(const StringsValueType& group_name);
+ private:
+ PermissionsList& list_;
+ const policy_table::Strings& preconsented_;
};
/**
* @param permissions Struct to be filled with provided params
*/
void FillFunctionalGroupPermissions(
- FunctionalGroupIDs& ids,
- FunctionalGroupNames& names,
- GroupConsent state,
- std::vector<FunctionalGroupPermission>& permissions);
+ FunctionalGroupIDs& ids,
+ FunctionalGroupNames& names,
+ GroupConsent state,
+ std::vector<FunctionalGroupPermission>& permissions);
}
virtual void set_listener(PolicyListener* listener) = 0;
/**
- *@brief Loads Policy Table from json file. Used for loading
- * Preloaded Policy Table or after Master Reset of the system.
- *@param file_name Path to preloaded PT file
- * @return bool Success of operation
+ * Inits Policy Table
+ * @param file_name Path to preloaded PT file
+ * @return true if successfully
*/
- virtual bool LoadPTFromFile(const std::string& file_name) = 0;
+ virtual bool InitPT(const std::string& file_name) = 0;
/**
* @brief Updates Policy Table from binary message received from
virtual bool LoadPT(const std::string& file, const BinaryMessage& pt_content) = 0;
/**
+ * Resets Policy Table
+ * @param file_name Path to preloaded PT file
+ * @return true if successfully
+ */
+ virtual bool ResetPT(const std::string& file_name) = 0;
+
+ /**
* @brief Gets URL for sending PTS to from PT itself.
* @param service_type Service specifies user of URL
* @return string URL
const std::string& device_id) = 0;
/**
+ * @brief Get user consent for application
+ * @param device_id Device id
+ * @param policy_app_id Unique application id
+ * @param permissions Array of functional groups permissions
+ */
+ virtual void GetUserConsentForApp(
+ const std::string& device_id, const std::string& policy_app_id,
+ std::vector<FunctionalGroupPermission>& permissions) = 0;
+
+ /**
* @brief Set user consent for mobile device data connection
* @param device_id Unique device identifier
* @param is_allowed User consent for usage device data connection
const std::string& application_id) = 0;
/**
+ * Marks device as upaired
+ * @param device_id id device
+ */
+ virtual void MarkUnpairedDevice(const std::string& device_id) = 0;
+
+ /**
* @brief Removes unpaired device records and related records from DB
* @param device_ids List of device_id, which should be removed
* @return true, if succedeed, otherwise - false
*/
- virtual bool CleanupUnpairedDevices(const DeviceIds& device_ids) = 0;
+ virtual bool CleanupUnpairedDevices() = 0;
/**
* @brief Check if app can keep context.
#include "utils/lock.h"
#include "policy/policy_manager.h"
#include "policy/policy_table.h"
-#include "policy_table_interface_base/functions.h"
+#include "./functions.h"
#include "usage_statistics/statistics_manager.h"
namespace policy_table = rpc::policy_table_interface_base;
struct CheckAppPolicy;
class PolicyManagerImpl : public PolicyManager {
- public:
- PolicyManagerImpl();
- virtual ~PolicyManagerImpl();
- void ResetDefaultPT(const PolicyTable& policy_table);
- virtual void set_listener(PolicyListener* listener);
- PolicyListener* listener() const {
- return listener_;
- }
- virtual bool LoadPTFromFile(const std::string& file_name);
- virtual bool LoadPT(const std::string& file, const BinaryMessage& pt_content);
+ public:
+ PolicyManagerImpl();
+ virtual ~PolicyManagerImpl();
+ void ResetDefaultPT(const PolicyTable& policy_table);
+ virtual void set_listener(PolicyListener* listener);
+ PolicyListener* listener() const {
+ return listener_;
+ }
+ virtual bool InitPT(const std::string& file_name);
+ virtual bool LoadPT(const std::string& file, const BinaryMessage& pt_content);
+ virtual bool ResetPT(const std::string& file_name);
virtual std::string GetUpdateUrl(int service_type);
virtual EndpointUrls GetUpdateUrls(int service_type);
- virtual BinaryMessageSptr RequestPTUpdate();
- virtual CheckPermissionResult CheckPermissions(const PTString& app_id,
- const PTString& hmi_level,
- const PTString& rpc);
- virtual bool ResetUserConsent();
- virtual bool ExceededIgnitionCycles();
- virtual bool ExceededDays(int days);
- virtual bool ExceededKilometers(int kilometers);
- virtual void IncrementIgnitionCycles();
- virtual void CheckAppPolicyState(const std::string& application_id);
- virtual PolicyTableStatus GetPolicyTableStatus();
- virtual void ResetRetrySequence();
- virtual int NextRetryTimeout();
- virtual int TimeoutExchange();
- virtual const std::vector<int> RetrySequenceDelaysSeconds();
- virtual void OnExceededTimeout();
- virtual void PTUpdatedAt(int kilometers, int days_after_epoch);
-
- /**
- * Refresh data about retry sequence from policy table
- */
- virtual void RefreshRetrySequence();
- virtual DeviceConsent GetUserConsentForDevice(const std::string& device_id);
- virtual void SetUserConsentForDevice(const std::string& device_id,
- bool is_allowed);
+ virtual BinaryMessageSptr RequestPTUpdate();
+ virtual CheckPermissionResult CheckPermissions(const PTString& app_id,
+ const PTString& hmi_level,
+ const PTString& rpc);
+ virtual bool ResetUserConsent();
+ virtual bool ExceededIgnitionCycles();
+ virtual bool ExceededDays(int days);
+ virtual bool ExceededKilometers(int kilometers);
+ virtual void IncrementIgnitionCycles();
+ virtual void CheckAppPolicyState(const std::string& application_id);
+ virtual PolicyTableStatus GetPolicyTableStatus();
+ virtual void ResetRetrySequence();
+ virtual int NextRetryTimeout();
+ virtual int TimeoutExchange();
+ virtual const std::vector<int> RetrySequenceDelaysSeconds();
+ virtual void OnExceededTimeout();
+ virtual void PTUpdatedAt(int kilometers, int days_after_epoch);
+
+ /**
+ * Refresh data about retry sequence from policy table
+ */
+ virtual void RefreshRetrySequence();
+ virtual DeviceConsent GetUserConsentForDevice(const std::string& device_id);
+ virtual void GetUserConsentForApp(
+ const std::string& device_id, const std::string& policy_app_id,
+ std::vector<FunctionalGroupPermission>& permissions);
+ virtual void SetUserConsentForDevice(const std::string& device_id,
+ bool is_allowed);
virtual bool ReactOnUserDevConsentForApp(const std::string app_id,
bool is_device_allowed);
- virtual bool GetInitialAppData(const std::string& application_id,
- StringArray* nicknames = NULL,
- StringArray* app_hmi_types = NULL);
+ virtual bool GetInitialAppData(const std::string& application_id,
+ StringArray* nicknames = NULL,
+ StringArray* app_hmi_types = NULL);
- virtual void SetDeviceInfo(const std::string& device_id,
- const DeviceInfo& device_info);
+ virtual void SetDeviceInfo(const std::string& device_id,
+ const DeviceInfo& device_info);
- virtual void SetUserConsentForApp(const PermissionConsent& permissions);
+ virtual void SetUserConsentForApp(const PermissionConsent& permissions);
- virtual bool GetDefaultHmi(const std::string& policy_app_id,
- std::string* default_hmi);
+ virtual bool GetDefaultHmi(const std::string& policy_app_id,
+ std::string* default_hmi);
- virtual bool GetPriority(const std::string& policy_app_id,
- std::string* priority);
+ virtual bool GetPriority(const std::string& policy_app_id,
+ std::string* priority);
- virtual std::vector<UserFriendlyMessage> GetUserFriendlyMessages(
+ virtual std::vector<UserFriendlyMessage> GetUserFriendlyMessages(
const std::vector<std::string>& message_code, const std::string& language);
- virtual bool IsApplicationRevoked(const std::string& app_id) const;
+ virtual bool IsApplicationRevoked(const std::string& app_id) const;
- virtual void GetUserPermissionsForApp(
+ virtual void GetUserPermissionsForApp(
const std::string& device_id, const std::string& policy_app_id,
std::vector<FunctionalGroupPermission>& permissions);
- virtual std::string& GetCurrentDeviceId(const std::string& policy_app_id);
+ virtual std::string& GetCurrentDeviceId(const std::string& policy_app_id);
- virtual void SetSystemLanguage(const std::string& language);
+ virtual void SetSystemLanguage(const std::string& language);
- virtual void SetSystemInfo(const std::string& ccpu_version,
- const std::string& wers_country_code,
- const std::string& language);
+ virtual void SetSystemInfo(const std::string& ccpu_version,
+ const std::string& wers_country_code,
+ const std::string& language);
- // Interface StatisticsManager (begin)
- virtual void Increment(usage_statistics::GlobalCounterId type);
- virtual void Increment(const std::string& app_id,
- usage_statistics::AppCounterId type);
- virtual void Set(const std::string& app_id, usage_statistics::AppInfoId type,
- const std::string& value);
- virtual void Add(const std::string& app_id,
- usage_statistics::AppStopwatchId type,
- int32_t timespan_seconds);
- // Interface StatisticsManager (end)
+ // Interface StatisticsManager (begin)
+ virtual void Increment(usage_statistics::GlobalCounterId type);
+ virtual void Increment(const std::string& app_id,
+ usage_statistics::AppCounterId type);
+ virtual void Set(const std::string& app_id, usage_statistics::AppInfoId type,
+ const std::string& value);
+ virtual void Add(const std::string& app_id,
+ usage_statistics::AppStopwatchId type,
+ int32_t timespan_seconds);
+ // Interface StatisticsManager (end)
- AppPermissions GetAppPermissionsChanges(const std::string& app_id);
- void RemovePendingPermissionChanges(const std::string& app_id);
+ AppPermissions GetAppPermissionsChanges(const std::string& app_id);
+ void RemovePendingPermissionChanges(const std::string& app_id);
- void SendNotificationOnPermissionsUpdated(const std::string& application_id);
+ void SendNotificationOnPermissionsUpdated(const std::string& application_id);
- bool CleanupUnpairedDevices(const DeviceIds& device_ids);
+ bool CleanupUnpairedDevices();
- bool CanAppKeepContext(const std::string& app_id);
- bool CanAppStealFocus(const std::string& app_id);
+ bool CanAppKeepContext(const std::string& app_id);
+ bool CanAppStealFocus(const std::string& app_id);
+ void MarkUnpairedDevice(const std::string& device_id);
- protected:
- virtual utils::SharedPtr<policy_table::Table> Parse(
+ protected:
+
virtual utils::SharedPtr<policy_table::Table> Parse(
const BinaryMessage& pt_content);
- // virtual bool Validate();
- // virtual bool ValidateResponseAgainsRequest();
-
- private:
- /*
- * @brief Checks policy table update along with current data for any changes
- * in assigned functional group list of application
- *
- * @param Policy table update struct
- */
- void CheckPermissionsChanges(
+ // virtual bool Validate();
+ // virtual bool ValidateResponseAgainsRequest();
+ virtual bool LoadPTFromFile(const std::string& file_name);
+
+ private:
+ /*
+ * @brief Checks policy table update along with current data for any changes
+ * in assigned functional group list of application
+ *
+ * @param Policy table update struct
+ */
+ void CheckPermissionsChanges(
const utils::SharedPtr<policy_table::Table> update);
- /**
- * @brief Fill structure to be sent with OnPermissionsChanged notification
- *
- * @param Policy table struct, which contains rpc functional groups data
- * @param List of rpc functional group names, which should be checked
- * @param group_permission User permissions for functional groups
- * @param Notification struct to be filled and sent
- */
- void PrepareNotificationData(
+ /**
+ * @brief Fill structure to be sent with OnPermissionsChanged notification
+ *
+ * @param Policy table struct, which contains rpc functional groups data
+ * @param List of rpc functional group names, which should be checked
+ * @param group_permission User permissions for functional groups
+ * @param Notification struct to be filled and sent
+ */
+ void PrepareNotificationData(
const policy_table::FunctionalGroupings& groups,
const policy_table::Strings& group_names,
const std::vector<FunctionalGroupPermission>& group_permission,
Permissions& notification_data);
- /*
- * @brief Sets flag for update progress
- *
- * @param value
- */
- void set_exchange_in_progress(bool value);
-
- /*
- * @brief Sets flag for pending update
- *
- * @param value
- */
- void set_exchange_pending(bool value);
-
- /*
- * @brief Sets flag for update necessity
- *
- * @param value
- */
- void set_update_required(bool value);
-
- /**
- * @brief Add application id at the end of update permissions request list
- * @param Application id
- */
- void AddAppToUpdateList(const std::string& application_id);
-
- /**
- * @brief Remove first application in the update permissions request list
- */
- void RemoveAppFromUpdateList();
-
- int IsConsentNeeded(const std::string& app_id);
-
- /**
- * @brief Check update status and notify HMI on changes
- */
- void CheckUpdateStatus();
-
- PolicyListener* listener_;
- PolicyTable policy_table_;
- utils::SharedPtr<policy_table::Table> policy_table_snapshot_;
- bool exchange_in_progress_;
- bool update_required_;
- bool exchange_pending_;
- sync_primitives::Lock exchange_in_progress_lock_;
- sync_primitives::Lock update_required_lock_;
- sync_primitives::Lock exchange_pending_lock_;
- sync_primitives::Lock update_request_list_lock_;
- std::map<std::string, AppPermissions> app_permissions_diff_;
-
- /**
- * @brief List of application, which require update of permissions
- */
- std::list<std::string> update_requests_list_;
-
- /**
- * Timeout to wait response with UpdatePT
- */
- int retry_sequence_timeout_;
-
- /**
- * Seconds between retries to update PT
- */
- std::vector<int> retry_sequence_seconds_;
-
- /**
- * Current index trying of retry sequence
- */
- int retry_sequence_index_;
-
- /**
- * Lock for guarding retry sequence
- */
- sync_primitives::Lock retry_sequence_lock_;
-
- /**
- * Lock for guarding recording statistics
- */
- sync_primitives::Lock statistics_lock_;
-
- /**
- * @brief Last status of policy table update
- */
- policy::PolicyTableStatus last_update_status_;
-
- /**
- * @brief Device id, which is used during PTU handling for specific
- * application
- */
- std::string last_device_id_;
-
- friend struct CheckAppPolicy;
+ /*
+ * @brief Sets flag for update progress
+ *
+ * @param value
+ */
+ void set_exchange_in_progress(bool value);
+
+ /*
+ * @brief Sets flag for pending update
+ *
+ * @param value
+ */
+ void set_exchange_pending(bool value);
+
+ /*
+ * @brief Sets flag for update necessity
+ *
+ * @param value
+ */
+ void set_update_required(bool value);
+
+ /**
+ * @brief Add application id at the end of update permissions request list
+ * @param Application id
+ */
+ void AddAppToUpdateList(const std::string& application_id);
+
+ /**
+ * @brief Remove first application in the update permissions request list
+ */
+ void RemoveAppFromUpdateList();
+
+ int IsConsentNeeded(const std::string& app_id);
+
+ /**
+ * @brief Check update status and notify HMI on changes
+ */
+ void CheckUpdateStatus();
+
+ PolicyListener* listener_;
+ PolicyTable policy_table_;
+ utils::SharedPtr<policy_table::Table> policy_table_snapshot_;
+ bool exchange_in_progress_;
+ bool update_required_;
+ bool exchange_pending_;
+ sync_primitives::Lock exchange_in_progress_lock_;
+ sync_primitives::Lock update_required_lock_;
+ sync_primitives::Lock exchange_pending_lock_;
+ sync_primitives::Lock update_request_list_lock_;
+ std::map<std::string, AppPermissions> app_permissions_diff_;
+
+ /**
+ * @brief List of application, which require update of permissions
+ */
+ std::list<std::string> update_requests_list_;
+
+ /**
+ * Timeout to wait response with UpdatePT
+ */
+ int retry_sequence_timeout_;
+
+ /**
+ * Seconds between retries to update PT
+ */
+ std::vector<int> retry_sequence_seconds_;
+
+ /**
+ * Current index trying of retry sequence
+ */
+ int retry_sequence_index_;
+
+ /**
+ * Lock for guarding retry sequence
+ */
+ sync_primitives::Lock retry_sequence_lock_;
+
+ /**
+ * Lock for guarding recording statistics
+ */
+ sync_primitives::Lock statistics_lock_;
+
+ /**
+ * @brief Last status of policy table update
+ */
+ policy::PolicyTableStatus last_update_status_;
+
+ /**
+ * @brief Device id, which is used during PTU handling for specific
+ * application
+ */
+ std::string last_device_id_;
+
+ /**
+ * @brief Holds device ids, which were unpaired
+ */
+ DeviceIds unpaired_device_ids_;
+
+ friend struct CheckAppPolicy;
};
} // namespace policy
kTypeAllowed,
kTypeDisallowed,
kTypePreconsented,
- kTypeGeneral // means, all types above
+ kTypeGeneral, // means, all types above
+ kTypePreDataConsented,
+ kTypeDevice
};
/**
/**
* @brief Array of device ids, which are an identifiers in policy table
*/
-typedef std::set<std::string> DeviceIds;
+typedef std::vector<std::string> DeviceIds;
} // namespace policy
virtual bool ResetUserConsent() = 0;
/**
+ * @brief Reset user consent for device data
+ * @return
+ */
+ virtual bool ResetDeviceConsents() = 0;
+
+ /**
+ * @brief Reset user consent for applications permissions
+ * @return
+ */
+ virtual bool ResetAppConsents() = 0;
+
+ /**
* @brief Get user permissions for device data usage
* @param device_id Generated or obtained id of device
* @param consented_groups Groups consented by user
int seconds) const = 0;
virtual bool CountUnconsentedGroups(const std::string& policy_app_id,
+ const std::string& device_id,
int* result) const = 0;
/**
* @return true, if succeeded, otherwise - false
*/
virtual bool SetIsPredata(const std::string& app_id, bool is_pre_data) = 0;
+
+ /**
+ * @brief Removes unpaired devices
+ * @return true if success
+ */
+ virtual bool CleanupUnpairedDevices(const DeviceIds& device_ids) const = 0;
+
+ /**
+ * Sets flag of unpaired device
+ * @param device_id
+ * @return true if success
+ */
+ virtual bool SetUnpairedDevice(const std::string& device_id) const = 0;
+
+ /**
+ * Gets list of unpaired devices
+ * @param device_ids output list
+ * @return true if success
+ */
+ virtual bool UnpairedDevicesList(DeviceIds* device_ids) const = 0;
};
} // namespace policy
#include <vector>
#include <string>
#include "policy/policy_types.h"
-#include "policy_table_interface_base/types.h"
+#include "./types.h"
namespace policy_table = rpc::policy_table_interface_base;
virtual bool Clear() = 0;
/**
+ * Drops policy table (schema and content)
+ * @return true if successfully
+ */
+ virtual bool Drop() = 0;
+
+ /**
* @brief Get snapshot of Policy Table
* including app_policies, functional_groups,
* device_info, statistics, excluding user messages
* @return true if success
*/
virtual bool SetDefaultPolicy(const std::string& app_id) = 0;
-
- /**
- * @brief Removes unpaired device records and related records from DB
- * @param device_ids List of device_id, which should be removed
- * @return true, if succedeed, otherwise - false
- */
- virtual bool CleanupUnpairedDevices(const DeviceIds& device_ids) = 0;
};
} // namespace policy
extern const std::string kSelectKeepContext;
extern const std::string kSelectStealFocus;
-extern const std::string kResetUserConsent;
+extern const std::string kResetDeviceConsents;
+extern const std::string kResetAppConsents;
extern const std::string kCountDeviceConsentGroup;
extern const std::string kCountDevice;
extern const std::string kSelectDeviceConsentedGroup;
extern const std::string kSelectApplicationIsPreData;
extern const std::string kUpdateIsPredata;
extern const std::string kHasAppPreloadedGroups;
+extern const std::string kUpdateUnpairedDevice;
+extern const std::string kSelectUnpairedDevices;
} // namespace sql_pt_ext
} // namespace policy
std::string* default_hmi);
bool GetPriority(const std::string& policy_app_id, std::string* priority);
bool ResetUserConsent();
+ bool ResetDeviceConsents();
+ bool ResetAppConsents();
bool GetUserPermissionsForDevice(const std::string& device_id,
StringArray* consented_groups = NULL,
StringArray* disallowed_groups = NULL);
}
bool GetFunctionalGroupNames(FunctionalGroupNames& names);
- bool CleanupUnpairedDevices(const DeviceIds& device_ids);
+ bool CleanupUnpairedDevices(const DeviceIds& device_ids) const;
void Increment(const std::string& type) const;
void Increment(const std::string& app_id, const std::string& type) const;
bool SetPredataPolicy(const std::string& app_id);
bool SetIsPredata(const std::string& app_id, bool is_pre_data);
bool IsPredataPolicy(const std::string& app_id) const;
+ bool SetUnpairedDevice(const std::string& device_id) const;
+ bool UnpairedDevicesList(DeviceIds* device_ids) const;
private:
void GatherModuleMeta(policy_table::ModuleMeta* meta) const;
GroupConsent state,
std::vector<FunctionalGroupPermission>& permissions);
bool CountUnconsentedGroups(const std::string& policy_app_id,
+ const std::string& device_id,
int* result) const;
};
extern const std::string kCreateSchema;
extern const std::string kDropSchema;
+extern const std::string kDeleteData;
extern const std::string kCheckPgNumber;
extern const std::string kCheckDBIntegrity;
extern const std::string kSelectRpc;
extern const std::string kSelectApplicationRepresented;
extern const std::string kSelectApplicationIsDefault;
extern const std::string kUpdateIsDefault;
+extern const std::string kInsertInitData;
} // namespace sql_pt
} // namespace policy
#include <vector>
#include "policy/pt_representation.h"
#include "rpc_base/rpc_base.h"
-#include "policy_table_interface_base/types.h"
+#include "./types.h"
namespace policy_table = rpc::policy_table_interface_base;
InitResult Init();
bool Close();
bool Clear();
+ bool Drop();
virtual utils::SharedPtr<policy_table::Table> GenerateSnapshot() const;
bool Save(const policy_table::Table& table);
bool GetInitialAppData(const std::string& app_id, StringArray* nicknames =
virtual bool IsDefaultPolicy(const std::string& app_id) const;
virtual bool IsPredataPolicy(const std::string& app_id) const;
virtual bool SetDefaultPolicy(const std::string& app_id);
- bool CleanupUnpairedDevices(const DeviceIds& device_ids);
dbms::SQLDatabase* db() const;
- virtual bool SetIsDefault(const std::string& app_id, bool is_default);
+ virtual bool SetIsDefault(const std::string& app_id, bool is_default) const;
private:
static const std::string kDatabaseName;
+++ /dev/null
-/*
- Copyright (c) 2013, 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.
- */
-
-#ifndef SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SYNCP_ADAPTER_H_
-#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_SYNCP_ADAPTER_H_
-
-#include "policy/policy_types.h"
-
-namespace policy {
-class SyncPAdapter {
- public:
- SyncPAdapter();
- virtual ~SyncPAdapter();
- virtual bool ParseHeader(const PTString& input);
- virtual bool ComposeHeader();
- virtual PTString* Decrypt(const PTString& input);
- virtual PTString* Encrypt(const PTString& input);
- virtual bool ValidateUpdate();
-
- private:
- typedef unsigned int MessageID;
- struct Header {
- explicit Header(MessageID id = -1)
- : msg_id(id) {}
- MessageID msg_id;
- };
-
- Header snapshot_;
- Header update_;
-};
-} // namespace policy
-
-#endif
--- /dev/null
+# Copyright (c) 2013, 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.
+
+set(target policy_struct)
+
+include_directories(.)
+
+set(SOURCES
+ ./enums.cc
+ ./types.cc
+ ./validation.cc
+)
+
+add_library(${target} ${SOURCES})
+target_link_libraries(${target} Utils)
--- /dev/null
+// This file is generated, do not edit
+#include "./enums.h"
+
+namespace rpc {
+namespace policy_table_interface_base {
+bool IsValidEnum(Priority val) {
+ switch (val) {
+ case P_EMERGENCY: return true;
+ case P_NAVIGATION: return true;
+ case P_VOICECOM: return true;
+ case P_COMMUNICATION: return true;
+ case P_NORMAL: return true;
+ case P_NONE: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(Priority val) {
+ switch (val) {
+ case P_EMERGENCY: return "EMERGENCY";
+ case P_NAVIGATION: return "NAVIGATION";
+ case P_VOICECOM: return "VOICECOM";
+ case P_COMMUNICATION: return "COMMUNICATION";
+ case P_NORMAL: return "NORMAL";
+ case P_NONE: return "NONE";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, Priority* result) {
+ if ("EMERGENCY" == literal) {
+ *result = P_EMERGENCY;
+ return true;
+ } else if ("NAVIGATION" == literal) {
+ *result = P_NAVIGATION;
+ return true;
+ } else if ("VOICECOM" == literal) {
+ *result = P_VOICECOM;
+ return true;
+ } else if ("COMMUNICATION" == literal) {
+ *result = P_COMMUNICATION;
+ return true;
+ } else if ("NORMAL" == literal) {
+ *result = P_NORMAL;
+ return true;
+ } else if ("NONE" == literal) {
+ *result = P_NONE;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(HmiLevel val) {
+ switch (val) {
+ case HL_BACKGROUND: return true;
+ case HL_FULL: return true;
+ case HL_LIMITED: return true;
+ case HL_NONE: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(HmiLevel val) {
+ switch (val) {
+ case HL_BACKGROUND: return "BACKGROUND";
+ case HL_FULL: return "FULL";
+ case HL_LIMITED: return "LIMITED";
+ case HL_NONE: return "NONE";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, HmiLevel* result) {
+ if ("BACKGROUND" == literal) {
+ *result = HL_BACKGROUND;
+ return true;
+ } else if ("FULL" == literal) {
+ *result = HL_FULL;
+ return true;
+ } else if ("LIMITED" == literal) {
+ *result = HL_LIMITED;
+ return true;
+ } else if ("NONE" == literal) {
+ *result = HL_NONE;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(Parameter val) {
+ switch (val) {
+ case P_GPS: return true;
+ case P_SPEED: return true;
+ case P_ENGINETORQUE: return true;
+ case P_EXTERNALTEMPERATURE: return true;
+ case P_FUELLEVEL: return true;
+ case P_FUELLEVEL_STATE: return true;
+ case P_HEADLAMPSTATUS: return true;
+ case P_INSTANTFUELCONSUMPTION: return true;
+ case P_ODOMETER: return true;
+ case P_TIREPRESSURE: return true;
+ case P_WIPERSTATUS: return true;
+ case P_VIN: return true;
+ case P_ACCPEDALPOSITION: return true;
+ case P_BELTSTATUS: return true;
+ case P_DRIVERBRAKING: return true;
+ case P_PRNDL: return true;
+ case P_RPM: return true;
+ case P_STEERINGWHEELANGLE: return true;
+ case P_MYKEY: return true;
+ case P_AIRBAGSTATUS: return true;
+ case P_BODYINFORMATION: return true;
+ case P_CLUSTERMODESTATUS: return true;
+ case P_DEVICESTATUS: return true;
+ case P_EMERGENCYEVENT: return true;
+ case P_ECALLINFO: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(Parameter val) {
+ switch (val) {
+ case P_GPS: return "gps";
+ case P_SPEED: return "speed";
+ case P_ENGINETORQUE: return "engineTorque";
+ case P_EXTERNALTEMPERATURE: return "externalTemperature";
+ case P_FUELLEVEL: return "fuelLevel";
+ case P_FUELLEVEL_STATE: return "fuelLevel_State";
+ case P_HEADLAMPSTATUS: return "headLampStatus";
+ case P_INSTANTFUELCONSUMPTION: return "instantFuelConsumption";
+ case P_ODOMETER: return "odometer";
+ case P_TIREPRESSURE: return "tirePressure";
+ case P_WIPERSTATUS: return "wiperStatus";
+ case P_VIN: return "vin";
+ case P_ACCPEDALPOSITION: return "accPedalPosition";
+ case P_BELTSTATUS: return "beltStatus";
+ case P_DRIVERBRAKING: return "driverBraking";
+ case P_PRNDL: return "prndl";
+ case P_RPM: return "rpm";
+ case P_STEERINGWHEELANGLE: return "steeringWheelAngle";
+ case P_MYKEY: return "myKey";
+ case P_AIRBAGSTATUS: return "airbagStatus";
+ case P_BODYINFORMATION: return "bodyInformation";
+ case P_CLUSTERMODESTATUS: return "clusterModeStatus";
+ case P_DEVICESTATUS: return "deviceStatus";
+ case P_EMERGENCYEVENT: return "emergencyEvent";
+ case P_ECALLINFO: return "eCallInfo";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, Parameter* result) {
+ if ("gps" == literal) {
+ *result = P_GPS;
+ return true;
+ } else if ("speed" == literal) {
+ *result = P_SPEED;
+ return true;
+ } else if ("engineTorque" == literal) {
+ *result = P_ENGINETORQUE;
+ return true;
+ } else if ("externalTemperature" == literal) {
+ *result = P_EXTERNALTEMPERATURE;
+ return true;
+ } else if ("fuelLevel" == literal) {
+ *result = P_FUELLEVEL;
+ return true;
+ } else if ("fuelLevel_State" == literal) {
+ *result = P_FUELLEVEL_STATE;
+ return true;
+ } else if ("headLampStatus" == literal) {
+ *result = P_HEADLAMPSTATUS;
+ return true;
+ } else if ("instantFuelConsumption" == literal) {
+ *result = P_INSTANTFUELCONSUMPTION;
+ return true;
+ } else if ("odometer" == literal) {
+ *result = P_ODOMETER;
+ return true;
+ } else if ("tirePressure" == literal) {
+ *result = P_TIREPRESSURE;
+ return true;
+ } else if ("wiperStatus" == literal) {
+ *result = P_WIPERSTATUS;
+ return true;
+ } else if ("vin" == literal) {
+ *result = P_VIN;
+ return true;
+ } else if ("accPedalPosition" == literal) {
+ *result = P_ACCPEDALPOSITION;
+ return true;
+ } else if ("beltStatus" == literal) {
+ *result = P_BELTSTATUS;
+ return true;
+ } else if ("driverBraking" == literal) {
+ *result = P_DRIVERBRAKING;
+ return true;
+ } else if ("prndl" == literal) {
+ *result = P_PRNDL;
+ return true;
+ } else if ("rpm" == literal) {
+ *result = P_RPM;
+ return true;
+ } else if ("steeringWheelAngle" == literal) {
+ *result = P_STEERINGWHEELANGLE;
+ return true;
+ } else if ("myKey" == literal) {
+ *result = P_MYKEY;
+ return true;
+ } else if ("airbagStatus" == literal) {
+ *result = P_AIRBAGSTATUS;
+ return true;
+ } else if ("bodyInformation" == literal) {
+ *result = P_BODYINFORMATION;
+ return true;
+ } else if ("clusterModeStatus" == literal) {
+ *result = P_CLUSTERMODESTATUS;
+ return true;
+ } else if ("deviceStatus" == literal) {
+ *result = P_DEVICESTATUS;
+ return true;
+ } else if ("emergencyEvent" == literal) {
+ *result = P_EMERGENCYEVENT;
+ return true;
+ } else if ("eCallInfo" == literal) {
+ *result = P_ECALLINFO;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(AppHMIType val) {
+ switch (val) {
+ case AHT_DEFAULT: return true;
+ case AHT_COMMUNICATION: return true;
+ case AHT_MEDIA: return true;
+ case AHT_MESSAGING: return true;
+ case AHT_NAVIGATION: return true;
+ case AHT_INFORMATION: return true;
+ case AHT_SOCIAL: return true;
+ case AHT_BACKGROUND_PROCESS: return true;
+ case AHT_TESTING: return true;
+ case AHT_SYSTEM: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(AppHMIType val) {
+ switch (val) {
+ case AHT_DEFAULT: return "DEFAULT";
+ case AHT_COMMUNICATION: return "COMMUNICATION";
+ case AHT_MEDIA: return "MEDIA";
+ case AHT_MESSAGING: return "MESSAGING";
+ case AHT_NAVIGATION: return "NAVIGATION";
+ case AHT_INFORMATION: return "INFORMATION";
+ case AHT_SOCIAL: return "SOCIAL";
+ case AHT_BACKGROUND_PROCESS: return "BACKGROUND_PROCESS";
+ case AHT_TESTING: return "TESTING";
+ case AHT_SYSTEM: return "SYSTEM";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, AppHMIType* result) {
+ if ("DEFAULT" == literal) {
+ *result = AHT_DEFAULT;
+ return true;
+ } else if ("COMMUNICATION" == literal) {
+ *result = AHT_COMMUNICATION;
+ return true;
+ } else if ("MEDIA" == literal) {
+ *result = AHT_MEDIA;
+ return true;
+ } else if ("MESSAGING" == literal) {
+ *result = AHT_MESSAGING;
+ return true;
+ } else if ("NAVIGATION" == literal) {
+ *result = AHT_NAVIGATION;
+ return true;
+ } else if ("INFORMATION" == literal) {
+ *result = AHT_INFORMATION;
+ return true;
+ } else if ("SOCIAL" == literal) {
+ *result = AHT_SOCIAL;
+ return true;
+ } else if ("BACKGROUND_PROCESS" == literal) {
+ *result = AHT_BACKGROUND_PROCESS;
+ return true;
+ } else if ("TESTING" == literal) {
+ *result = AHT_TESTING;
+ return true;
+ } else if ("SYSTEM" == literal) {
+ *result = AHT_SYSTEM;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+const std::string kDefaultApp = "default";
+const std::string kPreDataConsentApp = "pre_DataConsent";
+const std::string kDeviceApp = "device";
+
+} // namespace policy_table_interface_base
+} // namespace rpc
+
--- /dev/null
+// This file is generated, do not edit
+#ifndef POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_ENUMS_H_
+#define POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_ENUMS_H_
+#include <string>
+
+namespace rpc {
+namespace policy_table_interface_base {
+
+enum Priority {
+ P_EMERGENCY,
+ P_NAVIGATION,
+ P_VOICECOM,
+ P_COMMUNICATION,
+ P_NORMAL,
+ P_NONE,
+};
+bool IsValidEnum(Priority val);
+const char* EnumToJsonString(Priority val);
+bool EnumFromJsonString(const std::string& literal, Priority* result);
+
+
+enum HmiLevel {
+ HL_BACKGROUND,
+ HL_FULL,
+ HL_LIMITED,
+ HL_NONE,
+};
+bool IsValidEnum(HmiLevel val);
+const char* EnumToJsonString(HmiLevel val);
+bool EnumFromJsonString(const std::string& literal, HmiLevel* result);
+
+
+enum Parameter {
+ P_GPS,
+ P_SPEED,
+ P_ENGINETORQUE,
+ P_EXTERNALTEMPERATURE,
+ P_FUELLEVEL,
+ P_FUELLEVEL_STATE,
+ P_HEADLAMPSTATUS,
+ P_INSTANTFUELCONSUMPTION,
+ P_ODOMETER,
+ P_TIREPRESSURE,
+ P_WIPERSTATUS,
+ P_VIN,
+ P_ACCPEDALPOSITION,
+ P_BELTSTATUS,
+ P_DRIVERBRAKING,
+ P_PRNDL,
+ P_RPM,
+ P_STEERINGWHEELANGLE,
+ P_MYKEY,
+ P_AIRBAGSTATUS,
+ P_BODYINFORMATION,
+ P_CLUSTERMODESTATUS,
+ P_DEVICESTATUS,
+ P_EMERGENCYEVENT,
+ P_ECALLINFO,
+};
+bool IsValidEnum(Parameter val);
+const char* EnumToJsonString(Parameter val);
+bool EnumFromJsonString(const std::string& literal, Parameter* result);
+
+
+enum AppHMIType {
+ AHT_DEFAULT,
+ AHT_COMMUNICATION,
+ AHT_MEDIA,
+ AHT_MESSAGING,
+ AHT_NAVIGATION,
+ AHT_INFORMATION,
+ AHT_SOCIAL,
+ AHT_BACKGROUND_PROCESS,
+ AHT_TESTING,
+ AHT_SYSTEM,
+};
+bool IsValidEnum(AppHMIType val);
+const char* EnumToJsonString(AppHMIType val);
+bool EnumFromJsonString(const std::string& literal, AppHMIType* result);
+
+extern const std::string kDefaultApp;
+extern const std::string kPreDataConsentApp;
+extern const std::string kDeviceApp;
+
+} // namespace policy_table_interface_base
+} // namespace rpc
+
+#endif // POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_ENUMS_H_
--- /dev/null
+// This file is generated, do not edit
+#ifndef POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_FUNCTIONS_H_
+#define POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_FUNCTIONS_H_
+#include "./enums.h"
+#include "./types.h"
+
+#endif // POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_FUNCTIONS_H_
--- /dev/null
+// This file is generated, do not edit
+#include "./types.h"
+#include "rpc_base/rpc_base_json_inl.h"
+
+namespace rpc {
+namespace policy_table_interface_base {
+// ApplicationParams methods
+ApplicationParams::ApplicationParams()
+ : CompositeType(kUninitialized) {
+}
+ApplicationParams::ApplicationParams(const Strings& groups)
+ : CompositeType(kUninitialized),
+ groups(groups) {
+}
+ApplicationParams::~ApplicationParams() {
+}
+ApplicationParams::ApplicationParams(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ groups(impl::ValueMember(value__, "groups")),
+ nicknames(impl::ValueMember(value__, "nicknames")),
+ AppHMIType(impl::ValueMember(value__, "AppHMIType")),
+ memory_kb(impl::ValueMember(value__, "memory_kb")),
+ heart_beat_timeout_ms(impl::ValueMember(value__, "heart_beat_timeout_ms")),
+ certificate(impl::ValueMember(value__, "certificate")) {
+}
+Json::Value ApplicationParams::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("groups", groups, &result__);
+ impl::WriteJsonField("nicknames", nicknames, &result__);
+ impl::WriteJsonField("AppHMIType", AppHMIType, &result__);
+ impl::WriteJsonField("memory_kb", memory_kb, &result__);
+ impl::WriteJsonField("heart_beat_timeout_ms", heart_beat_timeout_ms, &result__);
+ impl::WriteJsonField("certificate", certificate, &result__);
+ return result__;
+}
+bool ApplicationParams::is_valid() const {
+ if (!groups.is_valid()) {
+ return false;
+ }
+ if (!nicknames.is_valid()) {
+ return false;
+ }
+ if (!AppHMIType.is_valid()) {
+ return false;
+ }
+ if (!memory_kb.is_valid()) {
+ return false;
+ }
+ if (!heart_beat_timeout_ms.is_valid()) {
+ return false;
+ }
+ if (!certificate.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ApplicationParams::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ApplicationParams::struct_empty() const {
+ if (groups.is_initialized()) {
+ return false;
+ }
+ if (nicknames.is_initialized()) {
+ return false;
+ }
+
+ if (AppHMIType.is_initialized()) {
+ return false;
+ }
+ if (memory_kb.is_initialized()) {
+ return false;
+ }
+
+ if (heart_beat_timeout_ms.is_initialized()) {
+ return false;
+ }
+ if (certificate.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!groups.is_valid()) {
+ groups.ReportErrors(&report__->ReportSubobject("groups"));
+ }
+ if (!nicknames.is_valid()) {
+ nicknames.ReportErrors(&report__->ReportSubobject("nicknames"));
+ }
+ if (!AppHMIType.is_valid()) {
+ AppHMIType.ReportErrors(&report__->ReportSubobject("AppHMIType"));
+ }
+ if (!memory_kb.is_valid()) {
+ memory_kb.ReportErrors(&report__->ReportSubobject("memory_kb"));
+ }
+ if (!heart_beat_timeout_ms.is_valid()) {
+ heart_beat_timeout_ms.ReportErrors(&report__->ReportSubobject("heart_beat_timeout_ms"));
+ }
+ if (!certificate.is_valid()) {
+ certificate.ReportErrors(&report__->ReportSubobject("certificate"));
+ }
+}
+
+// RpcParameters methods
+RpcParameters::RpcParameters()
+ : CompositeType(kUninitialized) {
+}
+RpcParameters::RpcParameters(const HmiLevels& hmi_levels)
+ : CompositeType(kUninitialized),
+ hmi_levels(hmi_levels) {
+}
+RpcParameters::~RpcParameters() {
+}
+RpcParameters::RpcParameters(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ hmi_levels(impl::ValueMember(value__, "hmi_levels")),
+ parameters(impl::ValueMember(value__, "parameters")) {
+}
+Json::Value RpcParameters::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("hmi_levels", hmi_levels, &result__);
+ impl::WriteJsonField("parameters", parameters, &result__);
+ return result__;
+}
+bool RpcParameters::is_valid() const {
+ if (!hmi_levels.is_valid()) {
+ return false;
+ }
+ if (!parameters.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool RpcParameters::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool RpcParameters::struct_empty() const {
+ if (hmi_levels.is_initialized()) {
+ return false;
+ }
+ if (parameters.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void RpcParameters::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!hmi_levels.is_valid()) {
+ hmi_levels.ReportErrors(&report__->ReportSubobject("hmi_levels"));
+ }
+ if (!parameters.is_valid()) {
+ parameters.ReportErrors(&report__->ReportSubobject("parameters"));
+ }
+}
+
+// Rpcs methods
+Rpcs::Rpcs()
+ : CompositeType(kUninitialized) {
+}
+Rpcs::Rpcs(const Rpc& rpcs)
+ : CompositeType(kUninitialized),
+ rpcs(rpcs) {
+}
+Rpcs::~Rpcs() {
+}
+Rpcs::Rpcs(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ user_consent_prompt(impl::ValueMember(value__, "user_consent_prompt")),
+ rpcs(impl::ValueMember(value__, "rpcs")) {
+}
+Json::Value Rpcs::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("user_consent_prompt", user_consent_prompt, &result__);
+ impl::WriteJsonField("rpcs", rpcs, &result__);
+ return result__;
+}
+bool Rpcs::is_valid() const {
+ if (!user_consent_prompt.is_valid()) {
+ return false;
+ }
+ if (!rpcs.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool Rpcs::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool Rpcs::struct_empty() const {
+ if (user_consent_prompt.is_initialized()) {
+ return false;
+ }
+ if (rpcs.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void Rpcs::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!user_consent_prompt.is_valid()) {
+ user_consent_prompt.ReportErrors(&report__->ReportSubobject("user_consent_prompt"));
+ }
+ if (!rpcs.is_valid()) {
+ rpcs.ReportErrors(&report__->ReportSubobject("rpcs"));
+ }
+}
+
+// ModuleConfig methods
+ModuleConfig::ModuleConfig()
+ : CompositeType(kUninitialized) {
+}
+ModuleConfig::ModuleConfig(uint8_t exchange_after_x_ignition_cycles, int64_t exchange_after_x_kilometers, uint8_t exchange_after_x_days, uint16_t timeout_after_x_seconds, const SecondsBetweenRetries& seconds_between_retries, const ServiceEndpoints& endpoints, const NumberOfNotificationsPerMinute& notifications_per_minute_by_priority)
+ : CompositeType(kUninitialized),
+ exchange_after_x_ignition_cycles(exchange_after_x_ignition_cycles),
+ exchange_after_x_kilometers(exchange_after_x_kilometers),
+ exchange_after_x_days(exchange_after_x_days),
+ timeout_after_x_seconds(timeout_after_x_seconds),
+ seconds_between_retries(seconds_between_retries),
+ endpoints(endpoints),
+ notifications_per_minute_by_priority(notifications_per_minute_by_priority) {
+}
+ModuleConfig::~ModuleConfig() {
+}
+ModuleConfig::ModuleConfig(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ device_certificates(impl::ValueMember(value__, "device_certificates")),
+ preloaded_pt(impl::ValueMember(value__, "preloaded_pt")),
+ exchange_after_x_ignition_cycles(impl::ValueMember(value__, "exchange_after_x_ignition_cycles")),
+ exchange_after_x_kilometers(impl::ValueMember(value__, "exchange_after_x_kilometers")),
+ exchange_after_x_days(impl::ValueMember(value__, "exchange_after_x_days")),
+ timeout_after_x_seconds(impl::ValueMember(value__, "timeout_after_x_seconds")),
+ seconds_between_retries(impl::ValueMember(value__, "seconds_between_retries")),
+ endpoints(impl::ValueMember(value__, "endpoints")),
+ notifications_per_minute_by_priority(impl::ValueMember(value__, "notifications_per_minute_by_priority")),
+ vehicle_make(impl::ValueMember(value__, "vehicle_make")),
+ vehicle_model(impl::ValueMember(value__, "vehicle_model")),
+ vehicle_year(impl::ValueMember(value__, "vehicle_year")) {
+}
+Json::Value ModuleConfig::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("device_certificates", device_certificates, &result__);
+ impl::WriteJsonField("preloaded_pt", preloaded_pt, &result__);
+ impl::WriteJsonField("exchange_after_x_ignition_cycles", exchange_after_x_ignition_cycles, &result__);
+ impl::WriteJsonField("exchange_after_x_kilometers", exchange_after_x_kilometers, &result__);
+ impl::WriteJsonField("exchange_after_x_days", exchange_after_x_days, &result__);
+ impl::WriteJsonField("timeout_after_x_seconds", timeout_after_x_seconds, &result__);
+ impl::WriteJsonField("seconds_between_retries", seconds_between_retries, &result__);
+ impl::WriteJsonField("endpoints", endpoints, &result__);
+ impl::WriteJsonField("notifications_per_minute_by_priority", notifications_per_minute_by_priority, &result__);
+ impl::WriteJsonField("vehicle_make", vehicle_make, &result__);
+ impl::WriteJsonField("vehicle_model", vehicle_model, &result__);
+ impl::WriteJsonField("vehicle_year", vehicle_year, &result__);
+ return result__;
+}
+bool ModuleConfig::is_valid() const {
+ if (!device_certificates.is_valid()) {
+ return false;
+ }
+ if (!preloaded_pt.is_valid()) {
+ return false;
+ }
+ if (!exchange_after_x_ignition_cycles.is_valid()) {
+ return false;
+ }
+ if (!exchange_after_x_kilometers.is_valid()) {
+ return false;
+ }
+ if (!exchange_after_x_days.is_valid()) {
+ return false;
+ }
+ if (!timeout_after_x_seconds.is_valid()) {
+ return false;
+ }
+ if (!seconds_between_retries.is_valid()) {
+ return false;
+ }
+ if (!endpoints.is_valid()) {
+ return false;
+ }
+ if (!notifications_per_minute_by_priority.is_valid()) {
+ return false;
+ }
+ if (!vehicle_make.is_valid()) {
+ return false;
+ }
+ if (!vehicle_model.is_valid()) {
+ return false;
+ }
+ if (!vehicle_year.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ModuleConfig::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ModuleConfig::struct_empty() const {
+ if (device_certificates.is_initialized()) {
+ return false;
+ }
+ if (preloaded_pt.is_initialized()) {
+ return false;
+ }
+
+ if (exchange_after_x_ignition_cycles.is_initialized()) {
+ return false;
+ }
+ if (exchange_after_x_kilometers.is_initialized()) {
+ return false;
+ }
+
+ if (exchange_after_x_days.is_initialized()) {
+ return false;
+ }
+ if (timeout_after_x_seconds.is_initialized()) {
+ return false;
+ }
+
+ if (seconds_between_retries.is_initialized()) {
+ return false;
+ }
+ if (endpoints.is_initialized()) {
+ return false;
+ }
+
+ if (notifications_per_minute_by_priority.is_initialized()) {
+ return false;
+ }
+ if (vehicle_make.is_initialized()) {
+ return false;
+ }
+
+ if (vehicle_model.is_initialized()) {
+ return false;
+ }
+ if (vehicle_year.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void ModuleConfig::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!device_certificates.is_valid()) {
+ device_certificates.ReportErrors(&report__->ReportSubobject("device_certificates"));
+ }
+ if (!preloaded_pt.is_valid()) {
+ preloaded_pt.ReportErrors(&report__->ReportSubobject("preloaded_pt"));
+ }
+ if (!exchange_after_x_ignition_cycles.is_valid()) {
+ exchange_after_x_ignition_cycles.ReportErrors(&report__->ReportSubobject("exchange_after_x_ignition_cycles"));
+ }
+ if (!exchange_after_x_kilometers.is_valid()) {
+ exchange_after_x_kilometers.ReportErrors(&report__->ReportSubobject("exchange_after_x_kilometers"));
+ }
+ if (!exchange_after_x_days.is_valid()) {
+ exchange_after_x_days.ReportErrors(&report__->ReportSubobject("exchange_after_x_days"));
+ }
+ if (!timeout_after_x_seconds.is_valid()) {
+ timeout_after_x_seconds.ReportErrors(&report__->ReportSubobject("timeout_after_x_seconds"));
+ }
+ if (!seconds_between_retries.is_valid()) {
+ seconds_between_retries.ReportErrors(&report__->ReportSubobject("seconds_between_retries"));
+ }
+ if (!endpoints.is_valid()) {
+ endpoints.ReportErrors(&report__->ReportSubobject("endpoints"));
+ }
+ if (!notifications_per_minute_by_priority.is_valid()) {
+ notifications_per_minute_by_priority.ReportErrors(&report__->ReportSubobject("notifications_per_minute_by_priority"));
+ }
+ if (!vehicle_make.is_valid()) {
+ vehicle_make.ReportErrors(&report__->ReportSubobject("vehicle_make"));
+ }
+ if (!vehicle_model.is_valid()) {
+ vehicle_model.ReportErrors(&report__->ReportSubobject("vehicle_model"));
+ }
+ if (!vehicle_year.is_valid()) {
+ vehicle_year.ReportErrors(&report__->ReportSubobject("vehicle_year"));
+ }
+}
+
+// MessageString methods
+MessageString::MessageString()
+ : CompositeType(kUninitialized) {
+}
+MessageString::~MessageString() {
+}
+MessageString::MessageString(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ line1(impl::ValueMember(value__, "line1")),
+ line2(impl::ValueMember(value__, "line2")),
+ tts(impl::ValueMember(value__, "tts")),
+ label(impl::ValueMember(value__, "label")),
+ textBody(impl::ValueMember(value__, "textBody")) {
+}
+Json::Value MessageString::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("line1", line1, &result__);
+ impl::WriteJsonField("line2", line2, &result__);
+ impl::WriteJsonField("tts", tts, &result__);
+ impl::WriteJsonField("label", label, &result__);
+ impl::WriteJsonField("textBody", textBody, &result__);
+ return result__;
+}
+bool MessageString::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!line1.is_valid()) {
+ return false;
+ }
+ if (!line2.is_valid()) {
+ return false;
+ }
+ if (!tts.is_valid()) {
+ return false;
+ }
+ if (!label.is_valid()) {
+ return false;
+ }
+ if (!textBody.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool MessageString::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool MessageString::struct_empty() const {
+ if (line1.is_initialized()) {
+ return false;
+ }
+ if (line2.is_initialized()) {
+ return false;
+ }
+
+ if (tts.is_initialized()) {
+ return false;
+ }
+ if (label.is_initialized()) {
+ return false;
+ }
+
+ if (textBody.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void MessageString::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!line1.is_valid()) {
+ line1.ReportErrors(&report__->ReportSubobject("line1"));
+ }
+ if (!line2.is_valid()) {
+ line2.ReportErrors(&report__->ReportSubobject("line2"));
+ }
+ if (!tts.is_valid()) {
+ tts.ReportErrors(&report__->ReportSubobject("tts"));
+ }
+ if (!label.is_valid()) {
+ label.ReportErrors(&report__->ReportSubobject("label"));
+ }
+ if (!textBody.is_valid()) {
+ textBody.ReportErrors(&report__->ReportSubobject("textBody"));
+ }
+}
+
+// MessageLanguages methods
+MessageLanguages::MessageLanguages()
+ : CompositeType(kUninitialized) {
+}
+MessageLanguages::MessageLanguages(const Languages& languages)
+ : CompositeType(kUninitialized),
+ languages(languages) {
+}
+MessageLanguages::~MessageLanguages() {
+}
+MessageLanguages::MessageLanguages(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ languages(impl::ValueMember(value__, "languages")) {
+}
+Json::Value MessageLanguages::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("languages", languages, &result__);
+ return result__;
+}
+bool MessageLanguages::is_valid() const {
+ if (!languages.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool MessageLanguages::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool MessageLanguages::struct_empty() const {
+ if (languages.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void MessageLanguages::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!languages.is_valid()) {
+ languages.ReportErrors(&report__->ReportSubobject("languages"));
+ }
+}
+
+// ConsumerFriendlyMessages methods
+ConsumerFriendlyMessages::ConsumerFriendlyMessages()
+ : CompositeType(kUninitialized) {
+}
+ConsumerFriendlyMessages::ConsumerFriendlyMessages(const std::string& version)
+ : CompositeType(kUninitialized),
+ version(version) {
+}
+ConsumerFriendlyMessages::~ConsumerFriendlyMessages() {
+}
+ConsumerFriendlyMessages::ConsumerFriendlyMessages(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ version(impl::ValueMember(value__, "version")),
+ messages(impl::ValueMember(value__, "messages")) {
+}
+Json::Value ConsumerFriendlyMessages::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("version", version, &result__);
+ impl::WriteJsonField("messages", messages, &result__);
+ return result__;
+}
+bool ConsumerFriendlyMessages::is_valid() const {
+ if (!version.is_valid()) {
+ return false;
+ }
+ if (!messages.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ConsumerFriendlyMessages::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ConsumerFriendlyMessages::struct_empty() const {
+ if (version.is_initialized()) {
+ return false;
+ }
+ if (messages.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void ConsumerFriendlyMessages::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!version.is_valid()) {
+ version.ReportErrors(&report__->ReportSubobject("version"));
+ }
+ if (!messages.is_valid()) {
+ messages.ReportErrors(&report__->ReportSubobject("messages"));
+ }
+}
+
+// ModuleMeta methods
+ModuleMeta::ModuleMeta()
+ : CompositeType(kUninitialized) {
+}
+ModuleMeta::~ModuleMeta() {
+}
+ModuleMeta::ModuleMeta(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)) {
+}
+Json::Value ModuleMeta::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ return result__;
+}
+bool ModuleMeta::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ return Validate();
+}
+bool ModuleMeta::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ModuleMeta::struct_empty() const {
+ return true;
+}
+void ModuleMeta::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+}
+
+// AppLevel methods
+AppLevel::AppLevel()
+ : CompositeType(kUninitialized) {
+}
+AppLevel::~AppLevel() {
+}
+AppLevel::AppLevel(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)) {
+}
+Json::Value AppLevel::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ return result__;
+}
+bool AppLevel::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ return Validate();
+}
+bool AppLevel::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool AppLevel::struct_empty() const {
+ return true;
+}
+void AppLevel::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+}
+
+// UsageAndErrorCounts methods
+UsageAndErrorCounts::UsageAndErrorCounts()
+ : CompositeType(kUninitialized) {
+}
+UsageAndErrorCounts::~UsageAndErrorCounts() {
+}
+UsageAndErrorCounts::UsageAndErrorCounts(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ app_level(impl::ValueMember(value__, "app_level")) {
+}
+Json::Value UsageAndErrorCounts::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("app_level", app_level, &result__);
+ return result__;
+}
+bool UsageAndErrorCounts::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!app_level.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool UsageAndErrorCounts::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool UsageAndErrorCounts::struct_empty() const {
+ if (app_level.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void UsageAndErrorCounts::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!app_level.is_valid()) {
+ app_level.ReportErrors(&report__->ReportSubobject("app_level"));
+ }
+}
+
+// DeviceParams methods
+DeviceParams::DeviceParams()
+ : CompositeType(kUninitialized) {
+}
+DeviceParams::~DeviceParams() {
+}
+DeviceParams::DeviceParams(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)) {
+}
+Json::Value DeviceParams::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ return result__;
+}
+bool DeviceParams::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ return Validate();
+}
+bool DeviceParams::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool DeviceParams::struct_empty() const {
+ return true;
+}
+void DeviceParams::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+}
+
+// PolicyTable methods
+PolicyTable::PolicyTable()
+ : CompositeType(kUninitialized) {
+}
+PolicyTable::PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config)
+ : CompositeType(kUninitialized),
+ app_policies(app_policies),
+ functional_groupings(functional_groupings),
+ consumer_friendly_messages(consumer_friendly_messages),
+ module_config(module_config) {
+}
+PolicyTable::~PolicyTable() {
+}
+PolicyTable::PolicyTable(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ app_policies(impl::ValueMember(value__, "app_policies")),
+ functional_groupings(impl::ValueMember(value__, "functional_groupings")),
+ consumer_friendly_messages(impl::ValueMember(value__, "consumer_friendly_messages")),
+ module_config(impl::ValueMember(value__, "module_config")),
+ module_meta(impl::ValueMember(value__, "module_meta")),
+ usage_and_error_counts(impl::ValueMember(value__, "usage_and_error_counts")),
+ device_data(impl::ValueMember(value__, "device_data")) {
+}
+Json::Value PolicyTable::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("app_policies", app_policies, &result__);
+ impl::WriteJsonField("functional_groupings", functional_groupings, &result__);
+ impl::WriteJsonField("consumer_friendly_messages", consumer_friendly_messages, &result__);
+ impl::WriteJsonField("module_config", module_config, &result__);
+ impl::WriteJsonField("module_meta", module_meta, &result__);
+ impl::WriteJsonField("usage_and_error_counts", usage_and_error_counts, &result__);
+ impl::WriteJsonField("device_data", device_data, &result__);
+ return result__;
+}
+bool PolicyTable::is_valid() const {
+ if (!app_policies.is_valid()) {
+ return false;
+ }
+ if (!functional_groupings.is_valid()) {
+ return false;
+ }
+ if (!consumer_friendly_messages.is_valid()) {
+ return false;
+ }
+ if (!module_config.is_valid()) {
+ return false;
+ }
+ if (!module_meta.is_valid()) {
+ return false;
+ }
+ if (!usage_and_error_counts.is_valid()) {
+ return false;
+ }
+ if (!device_data.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool PolicyTable::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool PolicyTable::struct_empty() const {
+ if (app_policies.is_initialized()) {
+ return false;
+ }
+ if (functional_groupings.is_initialized()) {
+ return false;
+ }
+
+ if (consumer_friendly_messages.is_initialized()) {
+ return false;
+ }
+ if (module_config.is_initialized()) {
+ return false;
+ }
+
+ if (module_meta.is_initialized()) {
+ return false;
+ }
+ if (usage_and_error_counts.is_initialized()) {
+ return false;
+ }
+
+ if (device_data.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void PolicyTable::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!app_policies.is_valid()) {
+ app_policies.ReportErrors(&report__->ReportSubobject("app_policies"));
+ }
+ if (!functional_groupings.is_valid()) {
+ functional_groupings.ReportErrors(&report__->ReportSubobject("functional_groupings"));
+ }
+ if (!consumer_friendly_messages.is_valid()) {
+ consumer_friendly_messages.ReportErrors(&report__->ReportSubobject("consumer_friendly_messages"));
+ }
+ if (!module_config.is_valid()) {
+ module_config.ReportErrors(&report__->ReportSubobject("module_config"));
+ }
+ if (!module_meta.is_valid()) {
+ module_meta.ReportErrors(&report__->ReportSubobject("module_meta"));
+ }
+ if (!usage_and_error_counts.is_valid()) {
+ usage_and_error_counts.ReportErrors(&report__->ReportSubobject("usage_and_error_counts"));
+ }
+ if (!device_data.is_valid()) {
+ device_data.ReportErrors(&report__->ReportSubobject("device_data"));
+ }
+}
+
+// Table methods
+Table::Table()
+ : CompositeType(kUninitialized) {
+}
+Table::Table(const PolicyTable& policy_table)
+ : CompositeType(kUninitialized),
+ policy_table(policy_table) {
+}
+Table::~Table() {
+}
+Table::Table(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ policy_table(impl::ValueMember(value__, "policy_table")) {
+}
+Json::Value Table::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("policy_table", policy_table, &result__);
+ return result__;
+}
+bool Table::is_valid() const {
+ if (!policy_table.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool Table::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool Table::struct_empty() const {
+ if (policy_table.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void Table::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!policy_table.is_valid()) {
+ policy_table.ReportErrors(&report__->ReportSubobject("policy_table"));
+ }
+}
+
+} // namespace policy_table_interface_base
+} // namespace rpc
+
--- /dev/null
+// This file is generated, do not edit
+#ifndef POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_TYPES_H_
+#define POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_TYPES_H_
+#include "./enums.h"
+#include "./types.h"
+#include "rpc_base/rpc_message.h"
+namespace Json {
+class Value;
+} // namespace Json
+namespace rpc {
+namespace policy_table_interface_base {
+struct AppLevel;
+struct ApplicationParams;
+struct DeviceParams;
+struct MessageLanguages;
+struct MessageString;
+struct RpcParameters;
+struct Rpcs;
+} // namespace policy_table_interface_base
+} // namespace rpc
+
+
+namespace rpc {
+namespace policy_table_interface_base {
+
+typedef Array< String<1, 255>, 0, 255 > Strings;
+
+typedef Array< Enum<AppHMIType>, 0, 255 > AppHMITypes;
+
+typedef Array< Enum<HmiLevel>, 0, 4 > HmiLevels;
+
+typedef Array< Enum<Parameter>, 0, 24 > Parameters;
+
+typedef Map< RpcParameters, 0, 50 > Rpc;
+
+typedef Array< String<10, 255>, 1, 255 > URL;
+
+typedef Map< URL, 1, 255 > URLList;
+
+typedef Map< URLList, 1, 255 > ServiceEndpoints;
+
+typedef Map< Integer<uint8_t, 0, 255>, 0, 6 > NumberOfNotificationsPerMinute;
+
+typedef Array< Integer<uint16_t, 1, 1000>, 0, 10 > SecondsBetweenRetries;
+
+typedef Map< MessageString, 0, 500 > Languages;
+
+typedef Map< MessageLanguages, 0, 255 > Messages;
+
+typedef Map< AppLevel, 0, 255 > AppLevels;
+
+typedef Map< Stringifyable < Nullable< ApplicationParams > >, 1, 1000 > ApplicationPolicies;
+
+typedef Map< Rpcs, 1, 255 > FunctionalGroupings;
+
+typedef Map< DeviceParams, 0, 255 > DeviceData;
+
+struct ApplicationParams : CompositeType {
+ public:
+ Strings groups;
+ Optional< Strings > nicknames;
+ Optional< AppHMITypes > AppHMIType;
+ Optional< Integer<uint16_t, 1, 65225> > memory_kb;
+ Optional< Integer<uint16_t, 1, 65225> > heart_beat_timeout_ms;
+ Optional< String<0, 255> > certificate;
+ public:
+ ApplicationParams();
+ explicit ApplicationParams(const Strings& groups);
+ ~ApplicationParams();
+ explicit ApplicationParams(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct RpcParameters : CompositeType {
+ public:
+ HmiLevels hmi_levels;
+ Optional< Parameters > parameters;
+ public:
+ RpcParameters();
+ explicit RpcParameters(const HmiLevels& hmi_levels);
+ ~RpcParameters();
+ explicit RpcParameters(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct Rpcs : CompositeType {
+ public:
+ Optional< String<1, 255> > user_consent_prompt;
+ Nullable< Rpc > rpcs;
+ public:
+ Rpcs();
+ explicit Rpcs(const Rpc& rpcs);
+ ~Rpcs();
+ explicit Rpcs(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ModuleConfig : CompositeType {
+ public:
+ Optional< Map< String<1, 100>, 1, 255 > > device_certificates;
+ Optional< Boolean > preloaded_pt;
+ Integer<uint8_t, 0, 255> exchange_after_x_ignition_cycles;
+ Integer<int64_t, 0, 4294967296> exchange_after_x_kilometers;
+ Integer<uint8_t, 0, 255> exchange_after_x_days;
+ Integer<uint16_t, 0, 65535> timeout_after_x_seconds;
+ SecondsBetweenRetries seconds_between_retries;
+ ServiceEndpoints endpoints;
+ NumberOfNotificationsPerMinute notifications_per_minute_by_priority;
+ Optional< String<1, 100> > vehicle_make;
+ Optional< String<1, 100> > vehicle_model;
+ Optional< String<4, 4> > vehicle_year;
+ public:
+ ModuleConfig();
+ ModuleConfig(uint8_t exchange_after_x_ignition_cycles, int64_t exchange_after_x_kilometers, uint8_t exchange_after_x_days, uint16_t timeout_after_x_seconds, const SecondsBetweenRetries& seconds_between_retries, const ServiceEndpoints& endpoints, const NumberOfNotificationsPerMinute& notifications_per_minute_by_priority);
+ ~ModuleConfig();
+ explicit ModuleConfig(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct MessageString : CompositeType {
+ public:
+ Optional< String<1, 255> > line1;
+ Optional< String<1, 255> > line2;
+ Optional< String<1, 65535> > tts;
+ Optional< String<1, 255> > label;
+ Optional< String<1, 500> > textBody;
+ public:
+ MessageString();
+ ~MessageString();
+ explicit MessageString(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct MessageLanguages : CompositeType {
+ public:
+ Languages languages;
+ public:
+ MessageLanguages();
+ explicit MessageLanguages(const Languages& languages);
+ ~MessageLanguages();
+ explicit MessageLanguages(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ConsumerFriendlyMessages : CompositeType {
+ public:
+ String<1, 100> version;
+ Optional< Messages > messages;
+ public:
+ ConsumerFriendlyMessages();
+ explicit ConsumerFriendlyMessages(const std::string& version);
+ ~ConsumerFriendlyMessages();
+ explicit ConsumerFriendlyMessages(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ModuleMeta : CompositeType {
+ public:
+ public:
+ ModuleMeta();
+ ~ModuleMeta();
+ explicit ModuleMeta(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct AppLevel : CompositeType {
+ public:
+ public:
+ AppLevel();
+ ~AppLevel();
+ explicit AppLevel(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct UsageAndErrorCounts : CompositeType {
+ public:
+ Optional< AppLevels > app_level;
+ public:
+ UsageAndErrorCounts();
+ ~UsageAndErrorCounts();
+ explicit UsageAndErrorCounts(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct DeviceParams : CompositeType {
+ public:
+ public:
+ DeviceParams();
+ ~DeviceParams();
+ explicit DeviceParams(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct PolicyTable : CompositeType {
+ public:
+ ApplicationPolicies app_policies;
+ FunctionalGroupings functional_groupings;
+ Optional < ConsumerFriendlyMessages > consumer_friendly_messages;
+ ModuleConfig module_config;
+ Optional< ModuleMeta > module_meta;
+ Optional< UsageAndErrorCounts > usage_and_error_counts;
+ Optional< DeviceData > device_data;
+ public:
+ PolicyTable();
+ PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config);
+ ~PolicyTable();
+ explicit PolicyTable(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct Table : CompositeType {
+ public:
+ PolicyTable policy_table;
+ public:
+ Table();
+ explicit Table(const PolicyTable& policy_table);
+ ~Table();
+ explicit Table(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+} // namespace policy_table_interface_base
+} // namespace rpc
+
+#endif // POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_TYPES_H_
--- /dev/null
+// This file is generated, do not edit
+#include "./functions.h"
+#include "./types.h"
+
+namespace rpc {
+namespace policy_table_interface_base {
+bool ApplicationParams::Validate() const {
+ return true;
+}
+bool RpcParameters::Validate() const {
+ return true;
+}
+bool Rpcs::Validate() const {
+ return true;
+}
+bool ModuleConfig::Validate() const {
+ return true;
+}
+bool MessageString::Validate() const {
+ return true;
+}
+bool MessageLanguages::Validate() const {
+ return true;
+}
+bool ConsumerFriendlyMessages::Validate() const {
+ return true;
+}
+bool ModuleMeta::Validate() const {
+ return true;
+}
+bool AppLevel::Validate() const {
+ return true;
+}
+bool UsageAndErrorCounts::Validate() const {
+ return true;
+}
+bool DeviceParams::Validate() const {
+ return true;
+}
+bool PolicyTable::Validate() const {
+ for (ApplicationPolicies::const_iterator it = app_policies.begin();
+ app_policies.end() != it; ++it) {
+ if (kDeviceApp == it->first) {
+ if (it->second.AppHMIType.is_initialized()
+ || it->second.memory_kb.is_initialized()
+ || it->second.heart_beat_timeout_ms.is_initialized()
+ || it->second.nicknames.is_initialized()) {
+ initialization_state__ = kUninitialized;
+ return false;
+ }
+ continue;
+ }
+ if (kDefaultApp == it->first || kPreDataConsentApp == it->first) {
+ if (!it->second.memory_kb.is_initialized()
+ || !it->second.heart_beat_timeout_ms.is_initialized()
+ || it->second.nicknames.is_initialized()) {
+ initialization_state__ = kUninitialized;
+ return false;
+ }
+ continue;
+ }
+ if (!it->second.is_null() && !it->second.is_string()
+ && (!it->second.nicknames.is_initialized()
+ || !it->second.AppHMIType.is_initialized()
+ || !it->second.memory_kb.is_initialized()
+ || !it->second.heart_beat_timeout_ms.is_initialized())) {
+ initialization_state__ = kUninitialized;
+ return false;
+ }
+ }
+ return true;
+}
+bool Table::Validate() const {
+ return true;
+}
+} // namespace policy_table_interface_base
+} // namespace rpc
+
--- /dev/null
+# Copyright (c) 2013, 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.
+
+set(target policy_struct)
+
+include_directories(.)
+
+set(SOURCES
+ ./enums.cc
+ ./types.cc
+ ./validation.cc
+)
+
+add_library(${target} ${SOURCES})
+target_link_libraries(${target} Utils)
--- /dev/null
+// This file is generated, do not edit
+#include "./enums.h"
+
+namespace rpc {
+namespace policy_table_interface_base {
+bool IsValidEnum(Priority val) {
+ switch (val) {
+ case P_EMERGENCY: return true;
+ case P_NAVIGATION: return true;
+ case P_VOICECOM: return true;
+ case P_COMMUNICATION: return true;
+ case P_NORMAL: return true;
+ case P_NONE: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(Priority val) {
+ switch (val) {
+ case P_EMERGENCY: return "EMERGENCY";
+ case P_NAVIGATION: return "NAVIGATION";
+ case P_VOICECOM: return "VOICECOM";
+ case P_COMMUNICATION: return "COMMUNICATION";
+ case P_NORMAL: return "NORMAL";
+ case P_NONE: return "NONE";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, Priority* result) {
+ if ("EMERGENCY" == literal) {
+ *result = P_EMERGENCY;
+ return true;
+ } else if ("NAVIGATION" == literal) {
+ *result = P_NAVIGATION;
+ return true;
+ } else if ("VOICECOM" == literal) {
+ *result = P_VOICECOM;
+ return true;
+ } else if ("COMMUNICATION" == literal) {
+ *result = P_COMMUNICATION;
+ return true;
+ } else if ("NORMAL" == literal) {
+ *result = P_NORMAL;
+ return true;
+ } else if ("NONE" == literal) {
+ *result = P_NONE;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(HmiLevel val) {
+ switch (val) {
+ case HL_BACKGROUND: return true;
+ case HL_FULL: return true;
+ case HL_LIMITED: return true;
+ case HL_NONE: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(HmiLevel val) {
+ switch (val) {
+ case HL_BACKGROUND: return "BACKGROUND";
+ case HL_FULL: return "FULL";
+ case HL_LIMITED: return "LIMITED";
+ case HL_NONE: return "NONE";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, HmiLevel* result) {
+ if ("BACKGROUND" == literal) {
+ *result = HL_BACKGROUND;
+ return true;
+ } else if ("FULL" == literal) {
+ *result = HL_FULL;
+ return true;
+ } else if ("LIMITED" == literal) {
+ *result = HL_LIMITED;
+ return true;
+ } else if ("NONE" == literal) {
+ *result = HL_NONE;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(Parameter val) {
+ switch (val) {
+ case P_GPS: return true;
+ case P_SPEED: return true;
+ case P_ENGINETORQUE: return true;
+ case P_EXTERNALTEMPERATURE: return true;
+ case P_FUELLEVEL: return true;
+ case P_FUELLEVEL_STATE: return true;
+ case P_HEADLAMPSTATUS: return true;
+ case P_INSTANTFUELCONSUMPTION: return true;
+ case P_ODOMETER: return true;
+ case P_TIREPRESSURE: return true;
+ case P_WIPERSTATUS: return true;
+ case P_VIN: return true;
+ case P_ACCPEDALPOSITION: return true;
+ case P_BELTSTATUS: return true;
+ case P_DRIVERBRAKING: return true;
+ case P_PRNDL: return true;
+ case P_RPM: return true;
+ case P_STEERINGWHEELANGLE: return true;
+ case P_MYKEY: return true;
+ case P_AIRBAGSTATUS: return true;
+ case P_BODYINFORMATION: return true;
+ case P_CLUSTERMODESTATUS: return true;
+ case P_DEVICESTATUS: return true;
+ case P_EMERGENCYEVENT: return true;
+ case P_ECALLINFO: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(Parameter val) {
+ switch (val) {
+ case P_GPS: return "gps";
+ case P_SPEED: return "speed";
+ case P_ENGINETORQUE: return "engineTorque";
+ case P_EXTERNALTEMPERATURE: return "externalTemperature";
+ case P_FUELLEVEL: return "fuelLevel";
+ case P_FUELLEVEL_STATE: return "fuelLevel_State";
+ case P_HEADLAMPSTATUS: return "headLampStatus";
+ case P_INSTANTFUELCONSUMPTION: return "instantFuelConsumption";
+ case P_ODOMETER: return "odometer";
+ case P_TIREPRESSURE: return "tirePressure";
+ case P_WIPERSTATUS: return "wiperStatus";
+ case P_VIN: return "vin";
+ case P_ACCPEDALPOSITION: return "accPedalPosition";
+ case P_BELTSTATUS: return "beltStatus";
+ case P_DRIVERBRAKING: return "driverBraking";
+ case P_PRNDL: return "prndl";
+ case P_RPM: return "rpm";
+ case P_STEERINGWHEELANGLE: return "steeringWheelAngle";
+ case P_MYKEY: return "myKey";
+ case P_AIRBAGSTATUS: return "airbagStatus";
+ case P_BODYINFORMATION: return "bodyInformation";
+ case P_CLUSTERMODESTATUS: return "clusterModeStatus";
+ case P_DEVICESTATUS: return "deviceStatus";
+ case P_EMERGENCYEVENT: return "emergencyEvent";
+ case P_ECALLINFO: return "eCallInfo";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, Parameter* result) {
+ if ("gps" == literal) {
+ *result = P_GPS;
+ return true;
+ } else if ("speed" == literal) {
+ *result = P_SPEED;
+ return true;
+ } else if ("engineTorque" == literal) {
+ *result = P_ENGINETORQUE;
+ return true;
+ } else if ("externalTemperature" == literal) {
+ *result = P_EXTERNALTEMPERATURE;
+ return true;
+ } else if ("fuelLevel" == literal) {
+ *result = P_FUELLEVEL;
+ return true;
+ } else if ("fuelLevel_State" == literal) {
+ *result = P_FUELLEVEL_STATE;
+ return true;
+ } else if ("headLampStatus" == literal) {
+ *result = P_HEADLAMPSTATUS;
+ return true;
+ } else if ("instantFuelConsumption" == literal) {
+ *result = P_INSTANTFUELCONSUMPTION;
+ return true;
+ } else if ("odometer" == literal) {
+ *result = P_ODOMETER;
+ return true;
+ } else if ("tirePressure" == literal) {
+ *result = P_TIREPRESSURE;
+ return true;
+ } else if ("wiperStatus" == literal) {
+ *result = P_WIPERSTATUS;
+ return true;
+ } else if ("vin" == literal) {
+ *result = P_VIN;
+ return true;
+ } else if ("accPedalPosition" == literal) {
+ *result = P_ACCPEDALPOSITION;
+ return true;
+ } else if ("beltStatus" == literal) {
+ *result = P_BELTSTATUS;
+ return true;
+ } else if ("driverBraking" == literal) {
+ *result = P_DRIVERBRAKING;
+ return true;
+ } else if ("prndl" == literal) {
+ *result = P_PRNDL;
+ return true;
+ } else if ("rpm" == literal) {
+ *result = P_RPM;
+ return true;
+ } else if ("steeringWheelAngle" == literal) {
+ *result = P_STEERINGWHEELANGLE;
+ return true;
+ } else if ("myKey" == literal) {
+ *result = P_MYKEY;
+ return true;
+ } else if ("airbagStatus" == literal) {
+ *result = P_AIRBAGSTATUS;
+ return true;
+ } else if ("bodyInformation" == literal) {
+ *result = P_BODYINFORMATION;
+ return true;
+ } else if ("clusterModeStatus" == literal) {
+ *result = P_CLUSTERMODESTATUS;
+ return true;
+ } else if ("deviceStatus" == literal) {
+ *result = P_DEVICESTATUS;
+ return true;
+ } else if ("emergencyEvent" == literal) {
+ *result = P_EMERGENCYEVENT;
+ return true;
+ } else if ("eCallInfo" == literal) {
+ *result = P_ECALLINFO;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(AppHMIType val) {
+ switch (val) {
+ case AHT_DEFAULT: return true;
+ case AHT_COMMUNICATION: return true;
+ case AHT_MEDIA: return true;
+ case AHT_MESSAGING: return true;
+ case AHT_NAVIGATION: return true;
+ case AHT_INFORMATION: return true;
+ case AHT_SOCIAL: return true;
+ case AHT_BACKGROUND_PROCESS: return true;
+ case AHT_TESTING: return true;
+ case AHT_SYSTEM: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(AppHMIType val) {
+ switch (val) {
+ case AHT_DEFAULT: return "DEFAULT";
+ case AHT_COMMUNICATION: return "COMMUNICATION";
+ case AHT_MEDIA: return "MEDIA";
+ case AHT_MESSAGING: return "MESSAGING";
+ case AHT_NAVIGATION: return "NAVIGATION";
+ case AHT_INFORMATION: return "INFORMATION";
+ case AHT_SOCIAL: return "SOCIAL";
+ case AHT_BACKGROUND_PROCESS: return "BACKGROUND_PROCESS";
+ case AHT_TESTING: return "TESTING";
+ case AHT_SYSTEM: return "SYSTEM";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, AppHMIType* result) {
+ if ("DEFAULT" == literal) {
+ *result = AHT_DEFAULT;
+ return true;
+ } else if ("COMMUNICATION" == literal) {
+ *result = AHT_COMMUNICATION;
+ return true;
+ } else if ("MEDIA" == literal) {
+ *result = AHT_MEDIA;
+ return true;
+ } else if ("MESSAGING" == literal) {
+ *result = AHT_MESSAGING;
+ return true;
+ } else if ("NAVIGATION" == literal) {
+ *result = AHT_NAVIGATION;
+ return true;
+ } else if ("INFORMATION" == literal) {
+ *result = AHT_INFORMATION;
+ return true;
+ } else if ("SOCIAL" == literal) {
+ *result = AHT_SOCIAL;
+ return true;
+ } else if ("BACKGROUND_PROCESS" == literal) {
+ *result = AHT_BACKGROUND_PROCESS;
+ return true;
+ } else if ("TESTING" == literal) {
+ *result = AHT_TESTING;
+ return true;
+ } else if ("SYSTEM" == literal) {
+ *result = AHT_SYSTEM;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool IsValidEnum(Input val) {
+ switch (val) {
+ case I_GUI: return true;
+ case I_VUI: return true;
+ default: return false;
+ }
+}
+const char* EnumToJsonString(Input val) {
+ switch (val) {
+ case I_GUI: return "GUI";
+ case I_VUI: return "VUI";
+ default: return "";
+ }
+}
+bool EnumFromJsonString(const std::string& literal, Input* result) {
+ if ("GUI" == literal) {
+ *result = I_GUI;
+ return true;
+ } else if ("VUI" == literal) {
+ *result = I_VUI;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+const std::string kDefaultApp = "default";
+const std::string kPreDataConsentApp = "pre_DataConsent";
+const std::string kDeviceApp = "device";
+
+} // namespace policy_table_interface_base
+} // namespace rpc
+
--- /dev/null
+// This file is generated, do not edit
+#ifndef POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_ENUMS_H_
+#define POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_ENUMS_H_
+#include <string>
+
+namespace rpc {
+namespace policy_table_interface_base {
+
+enum Priority {
+ P_EMERGENCY,
+ P_NAVIGATION,
+ P_VOICECOM,
+ P_COMMUNICATION,
+ P_NORMAL,
+ P_NONE,
+};
+bool IsValidEnum(Priority val);
+const char* EnumToJsonString(Priority val);
+bool EnumFromJsonString(const std::string& literal, Priority* result);
+
+
+enum HmiLevel {
+ HL_BACKGROUND,
+ HL_FULL,
+ HL_LIMITED,
+ HL_NONE,
+};
+bool IsValidEnum(HmiLevel val);
+const char* EnumToJsonString(HmiLevel val);
+bool EnumFromJsonString(const std::string& literal, HmiLevel* result);
+
+
+enum Parameter {
+ P_GPS,
+ P_SPEED,
+ P_ENGINETORQUE,
+ P_EXTERNALTEMPERATURE,
+ P_FUELLEVEL,
+ P_FUELLEVEL_STATE,
+ P_HEADLAMPSTATUS,
+ P_INSTANTFUELCONSUMPTION,
+ P_ODOMETER,
+ P_TIREPRESSURE,
+ P_WIPERSTATUS,
+ P_VIN,
+ P_ACCPEDALPOSITION,
+ P_BELTSTATUS,
+ P_DRIVERBRAKING,
+ P_PRNDL,
+ P_RPM,
+ P_STEERINGWHEELANGLE,
+ P_MYKEY,
+ P_AIRBAGSTATUS,
+ P_BODYINFORMATION,
+ P_CLUSTERMODESTATUS,
+ P_DEVICESTATUS,
+ P_EMERGENCYEVENT,
+ P_ECALLINFO,
+};
+bool IsValidEnum(Parameter val);
+const char* EnumToJsonString(Parameter val);
+bool EnumFromJsonString(const std::string& literal, Parameter* result);
+
+
+enum AppHMIType {
+ AHT_DEFAULT,
+ AHT_COMMUNICATION,
+ AHT_MEDIA,
+ AHT_MESSAGING,
+ AHT_NAVIGATION,
+ AHT_INFORMATION,
+ AHT_SOCIAL,
+ AHT_BACKGROUND_PROCESS,
+ AHT_TESTING,
+ AHT_SYSTEM,
+};
+bool IsValidEnum(AppHMIType val);
+const char* EnumToJsonString(AppHMIType val);
+bool EnumFromJsonString(const std::string& literal, AppHMIType* result);
+
+
+enum Input {
+ I_GUI,
+ I_VUI,
+};
+bool IsValidEnum(Input val);
+const char* EnumToJsonString(Input val);
+bool EnumFromJsonString(const std::string& literal, Input* result);
+
+extern const std::string kDefaultApp;
+extern const std::string kPreDataConsentApp;
+extern const std::string kDeviceApp;
+
+} // namespace policy_table_interface_base
+} // namespace rpc
+
+#endif // POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_ENUMS_H_
--- /dev/null
+// This file is generated, do not edit
+#ifndef POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_FUNCTIONS_H_
+#define POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_FUNCTIONS_H_
+#include "./enums.h"
+#include "./types.h"
+
+#endif // POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_FUNCTIONS_H_
--- /dev/null
+// This file is generated, do not edit
+#include "./types.h"
+#include "rpc_base/rpc_base_json_inl.h"
+
+namespace rpc {
+namespace policy_table_interface_base {
+// ApplicationParams methods
+ApplicationParams::ApplicationParams()
+ : CompositeType(kUninitialized) {
+}
+ApplicationParams::ApplicationParams(const Strings& groups, Priority priority, HmiLevel default_hmi, bool keep_context, bool steal_focus)
+ : CompositeType(kUninitialized),
+ groups(groups),
+ priority(priority),
+ default_hmi(default_hmi),
+ keep_context(keep_context),
+ steal_focus(steal_focus) {
+}
+ApplicationParams::~ApplicationParams() {
+}
+ApplicationParams::ApplicationParams(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ groups(impl::ValueMember(value__, "groups")),
+ nicknames(impl::ValueMember(value__, "nicknames")),
+ preconsented_groups(impl::ValueMember(value__, "preconsented_groups")),
+ AppHMIType(impl::ValueMember(value__, "AppHMIType")),
+ priority(impl::ValueMember(value__, "priority")),
+ default_hmi(impl::ValueMember(value__, "default_hmi")),
+ keep_context(impl::ValueMember(value__, "keep_context")),
+ steal_focus(impl::ValueMember(value__, "steal_focus")),
+ memory_kb(impl::ValueMember(value__, "memory_kb")),
+ heart_beat_timeout_ms(impl::ValueMember(value__, "heart_beat_timeout_ms")),
+ certificate(impl::ValueMember(value__, "certificate")) {
+}
+Json::Value ApplicationParams::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("groups", groups, &result__);
+ impl::WriteJsonField("nicknames", nicknames, &result__);
+ impl::WriteJsonField("preconsented_groups", preconsented_groups, &result__);
+ impl::WriteJsonField("AppHMIType", AppHMIType, &result__);
+ impl::WriteJsonField("priority", priority, &result__);
+ impl::WriteJsonField("default_hmi", default_hmi, &result__);
+ impl::WriteJsonField("keep_context", keep_context, &result__);
+ impl::WriteJsonField("steal_focus", steal_focus, &result__);
+ impl::WriteJsonField("memory_kb", memory_kb, &result__);
+ impl::WriteJsonField("heart_beat_timeout_ms", heart_beat_timeout_ms, &result__);
+ impl::WriteJsonField("certificate", certificate, &result__);
+ return result__;
+}
+bool ApplicationParams::is_valid() const {
+ if (!groups.is_valid()) {
+ return false;
+ }
+ if (!nicknames.is_valid()) {
+ return false;
+ }
+ if (!preconsented_groups.is_valid()) {
+ return false;
+ }
+ if (!AppHMIType.is_valid()) {
+ return false;
+ }
+ if (!priority.is_valid()) {
+ return false;
+ }
+ if (!default_hmi.is_valid()) {
+ return false;
+ }
+ if (!keep_context.is_valid()) {
+ return false;
+ }
+ if (!steal_focus.is_valid()) {
+ return false;
+ }
+ if (!memory_kb.is_valid()) {
+ return false;
+ }
+ if (!heart_beat_timeout_ms.is_valid()) {
+ return false;
+ }
+ if (!certificate.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ApplicationParams::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ApplicationParams::struct_empty() const {
+ if (groups.is_initialized()) {
+ return false;
+ }
+ if (nicknames.is_initialized()) {
+ return false;
+ }
+
+ if (preconsented_groups.is_initialized()) {
+ return false;
+ }
+ if (AppHMIType.is_initialized()) {
+ return false;
+ }
+
+ if (priority.is_initialized()) {
+ return false;
+ }
+ if (default_hmi.is_initialized()) {
+ return false;
+ }
+
+ if (keep_context.is_initialized()) {
+ return false;
+ }
+ if (steal_focus.is_initialized()) {
+ return false;
+ }
+
+ if (memory_kb.is_initialized()) {
+ return false;
+ }
+ if (heart_beat_timeout_ms.is_initialized()) {
+ return false;
+ }
+
+ if (certificate.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!groups.is_valid()) {
+ groups.ReportErrors(&report__->ReportSubobject("groups"));
+ }
+ if (!nicknames.is_valid()) {
+ nicknames.ReportErrors(&report__->ReportSubobject("nicknames"));
+ }
+ if (!preconsented_groups.is_valid()) {
+ preconsented_groups.ReportErrors(&report__->ReportSubobject("preconsented_groups"));
+ }
+ if (!AppHMIType.is_valid()) {
+ AppHMIType.ReportErrors(&report__->ReportSubobject("AppHMIType"));
+ }
+ if (!priority.is_valid()) {
+ priority.ReportErrors(&report__->ReportSubobject("priority"));
+ }
+ if (!default_hmi.is_valid()) {
+ default_hmi.ReportErrors(&report__->ReportSubobject("default_hmi"));
+ }
+ if (!keep_context.is_valid()) {
+ keep_context.ReportErrors(&report__->ReportSubobject("keep_context"));
+ }
+ if (!steal_focus.is_valid()) {
+ steal_focus.ReportErrors(&report__->ReportSubobject("steal_focus"));
+ }
+ if (!memory_kb.is_valid()) {
+ memory_kb.ReportErrors(&report__->ReportSubobject("memory_kb"));
+ }
+ if (!heart_beat_timeout_ms.is_valid()) {
+ heart_beat_timeout_ms.ReportErrors(&report__->ReportSubobject("heart_beat_timeout_ms"));
+ }
+ if (!certificate.is_valid()) {
+ certificate.ReportErrors(&report__->ReportSubobject("certificate"));
+ }
+}
+
+// RpcParameters methods
+RpcParameters::RpcParameters()
+ : CompositeType(kUninitialized) {
+}
+RpcParameters::RpcParameters(const HmiLevels& hmi_levels)
+ : CompositeType(kUninitialized),
+ hmi_levels(hmi_levels) {
+}
+RpcParameters::~RpcParameters() {
+}
+RpcParameters::RpcParameters(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ hmi_levels(impl::ValueMember(value__, "hmi_levels")),
+ parameters(impl::ValueMember(value__, "parameters")) {
+}
+Json::Value RpcParameters::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("hmi_levels", hmi_levels, &result__);
+ impl::WriteJsonField("parameters", parameters, &result__);
+ return result__;
+}
+bool RpcParameters::is_valid() const {
+ if (!hmi_levels.is_valid()) {
+ return false;
+ }
+ if (!parameters.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool RpcParameters::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool RpcParameters::struct_empty() const {
+ if (hmi_levels.is_initialized()) {
+ return false;
+ }
+ if (parameters.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void RpcParameters::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!hmi_levels.is_valid()) {
+ hmi_levels.ReportErrors(&report__->ReportSubobject("hmi_levels"));
+ }
+ if (!parameters.is_valid()) {
+ parameters.ReportErrors(&report__->ReportSubobject("parameters"));
+ }
+}
+
+// Rpcs methods
+Rpcs::Rpcs()
+ : CompositeType(kUninitialized) {
+}
+Rpcs::Rpcs(const Rpc& rpcs)
+ : CompositeType(kUninitialized),
+ rpcs(rpcs) {
+}
+Rpcs::~Rpcs() {
+}
+Rpcs::Rpcs(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ user_consent_prompt(impl::ValueMember(value__, "user_consent_prompt")),
+ rpcs(impl::ValueMember(value__, "rpcs")) {
+}
+Json::Value Rpcs::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("user_consent_prompt", user_consent_prompt, &result__);
+ impl::WriteJsonField("rpcs", rpcs, &result__);
+ return result__;
+}
+bool Rpcs::is_valid() const {
+ if (!user_consent_prompt.is_valid()) {
+ return false;
+ }
+ if (!rpcs.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool Rpcs::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool Rpcs::struct_empty() const {
+ if (user_consent_prompt.is_initialized()) {
+ return false;
+ }
+ if (rpcs.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void Rpcs::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!user_consent_prompt.is_valid()) {
+ user_consent_prompt.ReportErrors(&report__->ReportSubobject("user_consent_prompt"));
+ }
+ if (!rpcs.is_valid()) {
+ rpcs.ReportErrors(&report__->ReportSubobject("rpcs"));
+ }
+}
+
+// ModuleConfig methods
+ModuleConfig::ModuleConfig()
+ : CompositeType(kUninitialized) {
+}
+ModuleConfig::ModuleConfig(uint8_t exchange_after_x_ignition_cycles, int64_t exchange_after_x_kilometers, uint8_t exchange_after_x_days, uint16_t timeout_after_x_seconds, const SecondsBetweenRetries& seconds_between_retries, const ServiceEndpoints& endpoints, const NumberOfNotificationsPerMinute& notifications_per_minute_by_priority)
+ : CompositeType(kUninitialized),
+ exchange_after_x_ignition_cycles(exchange_after_x_ignition_cycles),
+ exchange_after_x_kilometers(exchange_after_x_kilometers),
+ exchange_after_x_days(exchange_after_x_days),
+ timeout_after_x_seconds(timeout_after_x_seconds),
+ seconds_between_retries(seconds_between_retries),
+ endpoints(endpoints),
+ notifications_per_minute_by_priority(notifications_per_minute_by_priority) {
+}
+ModuleConfig::~ModuleConfig() {
+}
+ModuleConfig::ModuleConfig(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ device_certificates(impl::ValueMember(value__, "device_certificates")),
+ preloaded_pt(impl::ValueMember(value__, "preloaded_pt")),
+ exchange_after_x_ignition_cycles(impl::ValueMember(value__, "exchange_after_x_ignition_cycles")),
+ exchange_after_x_kilometers(impl::ValueMember(value__, "exchange_after_x_kilometers")),
+ exchange_after_x_days(impl::ValueMember(value__, "exchange_after_x_days")),
+ timeout_after_x_seconds(impl::ValueMember(value__, "timeout_after_x_seconds")),
+ seconds_between_retries(impl::ValueMember(value__, "seconds_between_retries")),
+ endpoints(impl::ValueMember(value__, "endpoints")),
+ notifications_per_minute_by_priority(impl::ValueMember(value__, "notifications_per_minute_by_priority")),
+ vehicle_make(impl::ValueMember(value__, "vehicle_make")),
+ vehicle_model(impl::ValueMember(value__, "vehicle_model")),
+ vehicle_year(impl::ValueMember(value__, "vehicle_year")) {
+}
+Json::Value ModuleConfig::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("device_certificates", device_certificates, &result__);
+ impl::WriteJsonField("preloaded_pt", preloaded_pt, &result__);
+ impl::WriteJsonField("exchange_after_x_ignition_cycles", exchange_after_x_ignition_cycles, &result__);
+ impl::WriteJsonField("exchange_after_x_kilometers", exchange_after_x_kilometers, &result__);
+ impl::WriteJsonField("exchange_after_x_days", exchange_after_x_days, &result__);
+ impl::WriteJsonField("timeout_after_x_seconds", timeout_after_x_seconds, &result__);
+ impl::WriteJsonField("seconds_between_retries", seconds_between_retries, &result__);
+ impl::WriteJsonField("endpoints", endpoints, &result__);
+ impl::WriteJsonField("notifications_per_minute_by_priority", notifications_per_minute_by_priority, &result__);
+ impl::WriteJsonField("vehicle_make", vehicle_make, &result__);
+ impl::WriteJsonField("vehicle_model", vehicle_model, &result__);
+ impl::WriteJsonField("vehicle_year", vehicle_year, &result__);
+ return result__;
+}
+bool ModuleConfig::is_valid() const {
+ if (!device_certificates.is_valid()) {
+ return false;
+ }
+ if (!preloaded_pt.is_valid()) {
+ return false;
+ }
+ if (!exchange_after_x_ignition_cycles.is_valid()) {
+ return false;
+ }
+ if (!exchange_after_x_kilometers.is_valid()) {
+ return false;
+ }
+ if (!exchange_after_x_days.is_valid()) {
+ return false;
+ }
+ if (!timeout_after_x_seconds.is_valid()) {
+ return false;
+ }
+ if (!seconds_between_retries.is_valid()) {
+ return false;
+ }
+ if (!endpoints.is_valid()) {
+ return false;
+ }
+ if (!notifications_per_minute_by_priority.is_valid()) {
+ return false;
+ }
+ if (!vehicle_make.is_valid()) {
+ return false;
+ }
+ if (!vehicle_model.is_valid()) {
+ return false;
+ }
+ if (!vehicle_year.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ModuleConfig::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ModuleConfig::struct_empty() const {
+ if (device_certificates.is_initialized()) {
+ return false;
+ }
+ if (preloaded_pt.is_initialized()) {
+ return false;
+ }
+
+ if (exchange_after_x_ignition_cycles.is_initialized()) {
+ return false;
+ }
+ if (exchange_after_x_kilometers.is_initialized()) {
+ return false;
+ }
+
+ if (exchange_after_x_days.is_initialized()) {
+ return false;
+ }
+ if (timeout_after_x_seconds.is_initialized()) {
+ return false;
+ }
+
+ if (seconds_between_retries.is_initialized()) {
+ return false;
+ }
+ if (endpoints.is_initialized()) {
+ return false;
+ }
+
+ if (notifications_per_minute_by_priority.is_initialized()) {
+ return false;
+ }
+ if (vehicle_make.is_initialized()) {
+ return false;
+ }
+
+ if (vehicle_model.is_initialized()) {
+ return false;
+ }
+ if (vehicle_year.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void ModuleConfig::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!device_certificates.is_valid()) {
+ device_certificates.ReportErrors(&report__->ReportSubobject("device_certificates"));
+ }
+ if (!preloaded_pt.is_valid()) {
+ preloaded_pt.ReportErrors(&report__->ReportSubobject("preloaded_pt"));
+ }
+ if (!exchange_after_x_ignition_cycles.is_valid()) {
+ exchange_after_x_ignition_cycles.ReportErrors(&report__->ReportSubobject("exchange_after_x_ignition_cycles"));
+ }
+ if (!exchange_after_x_kilometers.is_valid()) {
+ exchange_after_x_kilometers.ReportErrors(&report__->ReportSubobject("exchange_after_x_kilometers"));
+ }
+ if (!exchange_after_x_days.is_valid()) {
+ exchange_after_x_days.ReportErrors(&report__->ReportSubobject("exchange_after_x_days"));
+ }
+ if (!timeout_after_x_seconds.is_valid()) {
+ timeout_after_x_seconds.ReportErrors(&report__->ReportSubobject("timeout_after_x_seconds"));
+ }
+ if (!seconds_between_retries.is_valid()) {
+ seconds_between_retries.ReportErrors(&report__->ReportSubobject("seconds_between_retries"));
+ }
+ if (!endpoints.is_valid()) {
+ endpoints.ReportErrors(&report__->ReportSubobject("endpoints"));
+ }
+ if (!notifications_per_minute_by_priority.is_valid()) {
+ notifications_per_minute_by_priority.ReportErrors(&report__->ReportSubobject("notifications_per_minute_by_priority"));
+ }
+ if (!vehicle_make.is_valid()) {
+ vehicle_make.ReportErrors(&report__->ReportSubobject("vehicle_make"));
+ }
+ if (!vehicle_model.is_valid()) {
+ vehicle_model.ReportErrors(&report__->ReportSubobject("vehicle_model"));
+ }
+ if (!vehicle_year.is_valid()) {
+ vehicle_year.ReportErrors(&report__->ReportSubobject("vehicle_year"));
+ }
+}
+
+// MessageString methods
+MessageString::MessageString()
+ : CompositeType(kUninitialized) {
+}
+MessageString::~MessageString() {
+}
+MessageString::MessageString(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ line1(impl::ValueMember(value__, "line1")),
+ line2(impl::ValueMember(value__, "line2")),
+ tts(impl::ValueMember(value__, "tts")),
+ label(impl::ValueMember(value__, "label")),
+ textBody(impl::ValueMember(value__, "textBody")) {
+}
+Json::Value MessageString::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("line1", line1, &result__);
+ impl::WriteJsonField("line2", line2, &result__);
+ impl::WriteJsonField("tts", tts, &result__);
+ impl::WriteJsonField("label", label, &result__);
+ impl::WriteJsonField("textBody", textBody, &result__);
+ return result__;
+}
+bool MessageString::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!line1.is_valid()) {
+ return false;
+ }
+ if (!line2.is_valid()) {
+ return false;
+ }
+ if (!tts.is_valid()) {
+ return false;
+ }
+ if (!label.is_valid()) {
+ return false;
+ }
+ if (!textBody.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool MessageString::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool MessageString::struct_empty() const {
+ if (line1.is_initialized()) {
+ return false;
+ }
+ if (line2.is_initialized()) {
+ return false;
+ }
+
+ if (tts.is_initialized()) {
+ return false;
+ }
+ if (label.is_initialized()) {
+ return false;
+ }
+
+ if (textBody.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void MessageString::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!line1.is_valid()) {
+ line1.ReportErrors(&report__->ReportSubobject("line1"));
+ }
+ if (!line2.is_valid()) {
+ line2.ReportErrors(&report__->ReportSubobject("line2"));
+ }
+ if (!tts.is_valid()) {
+ tts.ReportErrors(&report__->ReportSubobject("tts"));
+ }
+ if (!label.is_valid()) {
+ label.ReportErrors(&report__->ReportSubobject("label"));
+ }
+ if (!textBody.is_valid()) {
+ textBody.ReportErrors(&report__->ReportSubobject("textBody"));
+ }
+}
+
+// MessageLanguages methods
+MessageLanguages::MessageLanguages()
+ : CompositeType(kUninitialized) {
+}
+MessageLanguages::MessageLanguages(const Languages& languages)
+ : CompositeType(kUninitialized),
+ languages(languages) {
+}
+MessageLanguages::~MessageLanguages() {
+}
+MessageLanguages::MessageLanguages(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ languages(impl::ValueMember(value__, "languages")) {
+}
+Json::Value MessageLanguages::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("languages", languages, &result__);
+ return result__;
+}
+bool MessageLanguages::is_valid() const {
+ if (!languages.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool MessageLanguages::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool MessageLanguages::struct_empty() const {
+ if (languages.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void MessageLanguages::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!languages.is_valid()) {
+ languages.ReportErrors(&report__->ReportSubobject("languages"));
+ }
+}
+
+// ConsumerFriendlyMessages methods
+ConsumerFriendlyMessages::ConsumerFriendlyMessages()
+ : CompositeType(kUninitialized) {
+}
+ConsumerFriendlyMessages::ConsumerFriendlyMessages(const std::string& version)
+ : CompositeType(kUninitialized),
+ version(version) {
+}
+ConsumerFriendlyMessages::~ConsumerFriendlyMessages() {
+}
+ConsumerFriendlyMessages::ConsumerFriendlyMessages(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ version(impl::ValueMember(value__, "version")),
+ messages(impl::ValueMember(value__, "messages")) {
+}
+Json::Value ConsumerFriendlyMessages::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("version", version, &result__);
+ impl::WriteJsonField("messages", messages, &result__);
+ return result__;
+}
+bool ConsumerFriendlyMessages::is_valid() const {
+ if (!version.is_valid()) {
+ return false;
+ }
+ if (!messages.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ConsumerFriendlyMessages::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ConsumerFriendlyMessages::struct_empty() const {
+ if (version.is_initialized()) {
+ return false;
+ }
+ if (messages.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void ConsumerFriendlyMessages::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!version.is_valid()) {
+ version.ReportErrors(&report__->ReportSubobject("version"));
+ }
+ if (!messages.is_valid()) {
+ messages.ReportErrors(&report__->ReportSubobject("messages"));
+ }
+}
+
+// ModuleMeta methods
+ModuleMeta::ModuleMeta()
+ : CompositeType(kUninitialized) {
+}
+ModuleMeta::~ModuleMeta() {
+}
+ModuleMeta::ModuleMeta(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ ccpu_version(impl::ValueMember(value__, "ccpu_version")),
+ language(impl::ValueMember(value__, "language")),
+ wers_country_code(impl::ValueMember(value__, "wers_country_code")),
+ pt_exchanged_at_odometer_x(impl::ValueMember(value__, "pt_exchanged_at_odometer_x")),
+ pt_exchanged_x_days_after_epoch(impl::ValueMember(value__, "pt_exchanged_x_days_after_epoch")),
+ ignition_cycles_since_last_exchange(impl::ValueMember(value__, "ignition_cycles_since_last_exchange")),
+ vin(impl::ValueMember(value__, "vin")) {
+}
+Json::Value ModuleMeta::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("ccpu_version", ccpu_version, &result__);
+ impl::WriteJsonField("language", language, &result__);
+ impl::WriteJsonField("wers_country_code", wers_country_code, &result__);
+ impl::WriteJsonField("pt_exchanged_at_odometer_x", pt_exchanged_at_odometer_x, &result__);
+ impl::WriteJsonField("pt_exchanged_x_days_after_epoch", pt_exchanged_x_days_after_epoch, &result__);
+ impl::WriteJsonField("ignition_cycles_since_last_exchange", ignition_cycles_since_last_exchange, &result__);
+ impl::WriteJsonField("vin", vin, &result__);
+ return result__;
+}
+bool ModuleMeta::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!ccpu_version.is_valid()) {
+ return false;
+ }
+ if (!language.is_valid()) {
+ return false;
+ }
+ if (!wers_country_code.is_valid()) {
+ return false;
+ }
+ if (!pt_exchanged_at_odometer_x.is_valid()) {
+ return false;
+ }
+ if (!pt_exchanged_x_days_after_epoch.is_valid()) {
+ return false;
+ }
+ if (!ignition_cycles_since_last_exchange.is_valid()) {
+ return false;
+ }
+ if (!vin.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ModuleMeta::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ModuleMeta::struct_empty() const {
+ if (ccpu_version.is_initialized()) {
+ return false;
+ }
+ if (language.is_initialized()) {
+ return false;
+ }
+
+ if (wers_country_code.is_initialized()) {
+ return false;
+ }
+ if (pt_exchanged_at_odometer_x.is_initialized()) {
+ return false;
+ }
+
+ if (pt_exchanged_x_days_after_epoch.is_initialized()) {
+ return false;
+ }
+ if (ignition_cycles_since_last_exchange.is_initialized()) {
+ return false;
+ }
+
+ if (vin.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void ModuleMeta::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!ccpu_version.is_valid()) {
+ ccpu_version.ReportErrors(&report__->ReportSubobject("ccpu_version"));
+ }
+ if (!language.is_valid()) {
+ language.ReportErrors(&report__->ReportSubobject("language"));
+ }
+ if (!wers_country_code.is_valid()) {
+ wers_country_code.ReportErrors(&report__->ReportSubobject("wers_country_code"));
+ }
+ if (!pt_exchanged_at_odometer_x.is_valid()) {
+ pt_exchanged_at_odometer_x.ReportErrors(&report__->ReportSubobject("pt_exchanged_at_odometer_x"));
+ }
+ if (!pt_exchanged_x_days_after_epoch.is_valid()) {
+ pt_exchanged_x_days_after_epoch.ReportErrors(&report__->ReportSubobject("pt_exchanged_x_days_after_epoch"));
+ }
+ if (!ignition_cycles_since_last_exchange.is_valid()) {
+ ignition_cycles_since_last_exchange.ReportErrors(&report__->ReportSubobject("ignition_cycles_since_last_exchange"));
+ }
+ if (!vin.is_valid()) {
+ vin.ReportErrors(&report__->ReportSubobject("vin"));
+ }
+}
+
+// AppLevel methods
+AppLevel::AppLevel()
+ : CompositeType(kUninitialized) {
+}
+AppLevel::AppLevel(uint16_t minutes_in_hmi_full, const std::string& app_registration_language_gui, const std::string& app_registration_language_vui, uint16_t count_of_rfcom_limit_reached, uint16_t minutes_in_hmi_limited, uint16_t minutes_in_hmi_background, uint16_t minutes_in_hmi_none, uint16_t count_of_user_selections, uint16_t count_of_rejections_sync_out_of_memory, uint16_t count_of_rejections_nickname_mismatch, uint16_t count_of_rejections_duplicate_name, uint16_t count_of_rejected_rpc_calls, uint16_t count_of_rpcs_sent_in_hmi_none, uint16_t count_of_removals_for_bad_behavior, uint16_t count_of_run_attempts_while_revoked)
+ : CompositeType(kUninitialized),
+ minutes_in_hmi_full(minutes_in_hmi_full),
+ app_registration_language_gui(app_registration_language_gui),
+ app_registration_language_vui(app_registration_language_vui),
+ count_of_rfcom_limit_reached(count_of_rfcom_limit_reached),
+ minutes_in_hmi_limited(minutes_in_hmi_limited),
+ minutes_in_hmi_background(minutes_in_hmi_background),
+ minutes_in_hmi_none(minutes_in_hmi_none),
+ count_of_user_selections(count_of_user_selections),
+ count_of_rejections_sync_out_of_memory(count_of_rejections_sync_out_of_memory),
+ count_of_rejections_nickname_mismatch(count_of_rejections_nickname_mismatch),
+ count_of_rejections_duplicate_name(count_of_rejections_duplicate_name),
+ count_of_rejected_rpc_calls(count_of_rejected_rpc_calls),
+ count_of_rpcs_sent_in_hmi_none(count_of_rpcs_sent_in_hmi_none),
+ count_of_removals_for_bad_behavior(count_of_removals_for_bad_behavior),
+ count_of_run_attempts_while_revoked(count_of_run_attempts_while_revoked) {
+}
+AppLevel::~AppLevel() {
+}
+AppLevel::AppLevel(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ minutes_in_hmi_full(impl::ValueMember(value__, "minutes_in_hmi_full")),
+ app_registration_language_gui(impl::ValueMember(value__, "app_registration_language_gui")),
+ app_registration_language_vui(impl::ValueMember(value__, "app_registration_language_vui")),
+ count_of_rfcom_limit_reached(impl::ValueMember(value__, "count_of_rfcom_limit_reached")),
+ minutes_in_hmi_limited(impl::ValueMember(value__, "minutes_in_hmi_limited")),
+ minutes_in_hmi_background(impl::ValueMember(value__, "minutes_in_hmi_background")),
+ minutes_in_hmi_none(impl::ValueMember(value__, "minutes_in_hmi_none")),
+ count_of_user_selections(impl::ValueMember(value__, "count_of_user_selections")),
+ count_of_rejections_sync_out_of_memory(impl::ValueMember(value__, "count_of_rejections_sync_out_of_memory")),
+ count_of_rejections_nickname_mismatch(impl::ValueMember(value__, "count_of_rejections_nickname_mismatch")),
+ count_of_rejections_duplicate_name(impl::ValueMember(value__, "count_of_rejections_duplicate_name")),
+ count_of_rejected_rpc_calls(impl::ValueMember(value__, "count_of_rejected_rpc_calls")),
+ count_of_rpcs_sent_in_hmi_none(impl::ValueMember(value__, "count_of_rpcs_sent_in_hmi_none")),
+ count_of_removals_for_bad_behavior(impl::ValueMember(value__, "count_of_removals_for_bad_behavior")),
+ count_of_run_attempts_while_revoked(impl::ValueMember(value__, "count_of_run_attempts_while_revoked")) {
+}
+Json::Value AppLevel::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("minutes_in_hmi_full", minutes_in_hmi_full, &result__);
+ impl::WriteJsonField("app_registration_language_gui", app_registration_language_gui, &result__);
+ impl::WriteJsonField("app_registration_language_vui", app_registration_language_vui, &result__);
+ impl::WriteJsonField("count_of_rfcom_limit_reached", count_of_rfcom_limit_reached, &result__);
+ impl::WriteJsonField("minutes_in_hmi_limited", minutes_in_hmi_limited, &result__);
+ impl::WriteJsonField("minutes_in_hmi_background", minutes_in_hmi_background, &result__);
+ impl::WriteJsonField("minutes_in_hmi_none", minutes_in_hmi_none, &result__);
+ impl::WriteJsonField("count_of_user_selections", count_of_user_selections, &result__);
+ impl::WriteJsonField("count_of_rejections_sync_out_of_memory", count_of_rejections_sync_out_of_memory, &result__);
+ impl::WriteJsonField("count_of_rejections_nickname_mismatch", count_of_rejections_nickname_mismatch, &result__);
+ impl::WriteJsonField("count_of_rejections_duplicate_name", count_of_rejections_duplicate_name, &result__);
+ impl::WriteJsonField("count_of_rejected_rpc_calls", count_of_rejected_rpc_calls, &result__);
+ impl::WriteJsonField("count_of_rpcs_sent_in_hmi_none", count_of_rpcs_sent_in_hmi_none, &result__);
+ impl::WriteJsonField("count_of_removals_for_bad_behavior", count_of_removals_for_bad_behavior, &result__);
+ impl::WriteJsonField("count_of_run_attempts_while_revoked", count_of_run_attempts_while_revoked, &result__);
+ return result__;
+}
+bool AppLevel::is_valid() const {
+ if (!minutes_in_hmi_full.is_valid()) {
+ return false;
+ }
+ if (!app_registration_language_gui.is_valid()) {
+ return false;
+ }
+ if (!app_registration_language_vui.is_valid()) {
+ return false;
+ }
+ if (!count_of_rfcom_limit_reached.is_valid()) {
+ return false;
+ }
+ if (!minutes_in_hmi_limited.is_valid()) {
+ return false;
+ }
+ if (!minutes_in_hmi_background.is_valid()) {
+ return false;
+ }
+ if (!minutes_in_hmi_none.is_valid()) {
+ return false;
+ }
+ if (!count_of_user_selections.is_valid()) {
+ return false;
+ }
+ if (!count_of_rejections_sync_out_of_memory.is_valid()) {
+ return false;
+ }
+ if (!count_of_rejections_nickname_mismatch.is_valid()) {
+ return false;
+ }
+ if (!count_of_rejections_duplicate_name.is_valid()) {
+ return false;
+ }
+ if (!count_of_rejected_rpc_calls.is_valid()) {
+ return false;
+ }
+ if (!count_of_rpcs_sent_in_hmi_none.is_valid()) {
+ return false;
+ }
+ if (!count_of_removals_for_bad_behavior.is_valid()) {
+ return false;
+ }
+ if (!count_of_run_attempts_while_revoked.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool AppLevel::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool AppLevel::struct_empty() const {
+ if (minutes_in_hmi_full.is_initialized()) {
+ return false;
+ }
+ if (app_registration_language_gui.is_initialized()) {
+ return false;
+ }
+
+ if (app_registration_language_vui.is_initialized()) {
+ return false;
+ }
+ if (count_of_rfcom_limit_reached.is_initialized()) {
+ return false;
+ }
+
+ if (minutes_in_hmi_limited.is_initialized()) {
+ return false;
+ }
+ if (minutes_in_hmi_background.is_initialized()) {
+ return false;
+ }
+
+ if (minutes_in_hmi_none.is_initialized()) {
+ return false;
+ }
+ if (count_of_user_selections.is_initialized()) {
+ return false;
+ }
+
+ if (count_of_rejections_sync_out_of_memory.is_initialized()) {
+ return false;
+ }
+ if (count_of_rejections_nickname_mismatch.is_initialized()) {
+ return false;
+ }
+
+ if (count_of_rejections_duplicate_name.is_initialized()) {
+ return false;
+ }
+ if (count_of_rejected_rpc_calls.is_initialized()) {
+ return false;
+ }
+
+ if (count_of_rpcs_sent_in_hmi_none.is_initialized()) {
+ return false;
+ }
+ if (count_of_removals_for_bad_behavior.is_initialized()) {
+ return false;
+ }
+
+ if (count_of_run_attempts_while_revoked.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void AppLevel::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!minutes_in_hmi_full.is_valid()) {
+ minutes_in_hmi_full.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_full"));
+ }
+ if (!app_registration_language_gui.is_valid()) {
+ app_registration_language_gui.ReportErrors(&report__->ReportSubobject("app_registration_language_gui"));
+ }
+ if (!app_registration_language_vui.is_valid()) {
+ app_registration_language_vui.ReportErrors(&report__->ReportSubobject("app_registration_language_vui"));
+ }
+ if (!count_of_rfcom_limit_reached.is_valid()) {
+ count_of_rfcom_limit_reached.ReportErrors(&report__->ReportSubobject("count_of_rfcom_limit_reached"));
+ }
+ if (!minutes_in_hmi_limited.is_valid()) {
+ minutes_in_hmi_limited.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_limited"));
+ }
+ if (!minutes_in_hmi_background.is_valid()) {
+ minutes_in_hmi_background.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_background"));
+ }
+ if (!minutes_in_hmi_none.is_valid()) {
+ minutes_in_hmi_none.ReportErrors(&report__->ReportSubobject("minutes_in_hmi_none"));
+ }
+ if (!count_of_user_selections.is_valid()) {
+ count_of_user_selections.ReportErrors(&report__->ReportSubobject("count_of_user_selections"));
+ }
+ if (!count_of_rejections_sync_out_of_memory.is_valid()) {
+ count_of_rejections_sync_out_of_memory.ReportErrors(&report__->ReportSubobject("count_of_rejections_sync_out_of_memory"));
+ }
+ if (!count_of_rejections_nickname_mismatch.is_valid()) {
+ count_of_rejections_nickname_mismatch.ReportErrors(&report__->ReportSubobject("count_of_rejections_nickname_mismatch"));
+ }
+ if (!count_of_rejections_duplicate_name.is_valid()) {
+ count_of_rejections_duplicate_name.ReportErrors(&report__->ReportSubobject("count_of_rejections_duplicate_name"));
+ }
+ if (!count_of_rejected_rpc_calls.is_valid()) {
+ count_of_rejected_rpc_calls.ReportErrors(&report__->ReportSubobject("count_of_rejected_rpc_calls"));
+ }
+ if (!count_of_rpcs_sent_in_hmi_none.is_valid()) {
+ count_of_rpcs_sent_in_hmi_none.ReportErrors(&report__->ReportSubobject("count_of_rpcs_sent_in_hmi_none"));
+ }
+ if (!count_of_removals_for_bad_behavior.is_valid()) {
+ count_of_removals_for_bad_behavior.ReportErrors(&report__->ReportSubobject("count_of_removals_for_bad_behavior"));
+ }
+ if (!count_of_run_attempts_while_revoked.is_valid()) {
+ count_of_run_attempts_while_revoked.ReportErrors(&report__->ReportSubobject("count_of_run_attempts_while_revoked"));
+ }
+}
+
+// UsageAndErrorCounts methods
+UsageAndErrorCounts::UsageAndErrorCounts()
+ : CompositeType(kUninitialized) {
+}
+UsageAndErrorCounts::~UsageAndErrorCounts() {
+}
+UsageAndErrorCounts::UsageAndErrorCounts(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ count_of_iap_buffer_full(impl::ValueMember(value__, "count_of_iap_buffer_full")),
+ count_sync_out_of_memory(impl::ValueMember(value__, "count_sync_out_of_memory")),
+ count_of_sync_reboots(impl::ValueMember(value__, "count_of_sync_reboots")),
+ app_level(impl::ValueMember(value__, "app_level")) {
+}
+Json::Value UsageAndErrorCounts::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("count_of_iap_buffer_full", count_of_iap_buffer_full, &result__);
+ impl::WriteJsonField("count_sync_out_of_memory", count_sync_out_of_memory, &result__);
+ impl::WriteJsonField("count_of_sync_reboots", count_of_sync_reboots, &result__);
+ impl::WriteJsonField("app_level", app_level, &result__);
+ return result__;
+}
+bool UsageAndErrorCounts::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!count_of_iap_buffer_full.is_valid()) {
+ return false;
+ }
+ if (!count_sync_out_of_memory.is_valid()) {
+ return false;
+ }
+ if (!count_of_sync_reboots.is_valid()) {
+ return false;
+ }
+ if (!app_level.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool UsageAndErrorCounts::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool UsageAndErrorCounts::struct_empty() const {
+ if (count_of_iap_buffer_full.is_initialized()) {
+ return false;
+ }
+ if (count_sync_out_of_memory.is_initialized()) {
+ return false;
+ }
+
+ if (count_of_sync_reboots.is_initialized()) {
+ return false;
+ }
+ if (app_level.is_initialized()) {
+ return false;
+ }
+
+ return true;
+}
+void UsageAndErrorCounts::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!count_of_iap_buffer_full.is_valid()) {
+ count_of_iap_buffer_full.ReportErrors(&report__->ReportSubobject("count_of_iap_buffer_full"));
+ }
+ if (!count_sync_out_of_memory.is_valid()) {
+ count_sync_out_of_memory.ReportErrors(&report__->ReportSubobject("count_sync_out_of_memory"));
+ }
+ if (!count_of_sync_reboots.is_valid()) {
+ count_of_sync_reboots.ReportErrors(&report__->ReportSubobject("count_of_sync_reboots"));
+ }
+ if (!app_level.is_valid()) {
+ app_level.ReportErrors(&report__->ReportSubobject("app_level"));
+ }
+}
+
+// ConsentRecords methods
+ConsentRecords::ConsentRecords()
+ : CompositeType(kUninitialized) {
+}
+ConsentRecords::~ConsentRecords() {
+}
+ConsentRecords::ConsentRecords(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ consent_groups(impl::ValueMember(value__, "consent_groups")),
+ input(impl::ValueMember(value__, "input")),
+ time_stamp(impl::ValueMember(value__, "time_stamp")) {
+}
+Json::Value ConsentRecords::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("consent_groups", consent_groups, &result__);
+ impl::WriteJsonField("input", input, &result__);
+ impl::WriteJsonField("time_stamp", time_stamp, &result__);
+ return result__;
+}
+bool ConsentRecords::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!consent_groups.is_valid()) {
+ return false;
+ }
+ if (!input.is_valid()) {
+ return false;
+ }
+ if (!time_stamp.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool ConsentRecords::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool ConsentRecords::struct_empty() const {
+ if (consent_groups.is_initialized()) {
+ return false;
+ }
+ if (input.is_initialized()) {
+ return false;
+ }
+
+ if (time_stamp.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void ConsentRecords::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!consent_groups.is_valid()) {
+ consent_groups.ReportErrors(&report__->ReportSubobject("consent_groups"));
+ }
+ if (!input.is_valid()) {
+ input.ReportErrors(&report__->ReportSubobject("input"));
+ }
+ if (!time_stamp.is_valid()) {
+ time_stamp.ReportErrors(&report__->ReportSubobject("time_stamp"));
+ }
+}
+
+// DeviceParams methods
+DeviceParams::DeviceParams()
+ : CompositeType(kUninitialized) {
+}
+DeviceParams::~DeviceParams() {
+}
+DeviceParams::DeviceParams(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ hardware(impl::ValueMember(value__, "hardware")),
+ firmware_rev(impl::ValueMember(value__, "firmware_rev")),
+ os(impl::ValueMember(value__, "os")),
+ os_version(impl::ValueMember(value__, "os_version")),
+ carrier(impl::ValueMember(value__, "carrier")),
+ user_consent_records(impl::ValueMember(value__, "user_consent_records")),
+ max_number_rfcom_ports(impl::ValueMember(value__, "max_number_rfcom_ports")) {
+}
+Json::Value DeviceParams::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("hardware", hardware, &result__);
+ impl::WriteJsonField("firmware_rev", firmware_rev, &result__);
+ impl::WriteJsonField("os", os, &result__);
+ impl::WriteJsonField("os_version", os_version, &result__);
+ impl::WriteJsonField("carrier", carrier, &result__);
+ impl::WriteJsonField("user_consent_records", user_consent_records, &result__);
+ impl::WriteJsonField("max_number_rfcom_ports", max_number_rfcom_ports, &result__);
+ return result__;
+}
+bool DeviceParams::is_valid() const {
+ if (struct_empty()) {
+ return initialization_state__ == kInitialized;
+ }
+ if (!hardware.is_valid()) {
+ return false;
+ }
+ if (!firmware_rev.is_valid()) {
+ return false;
+ }
+ if (!os.is_valid()) {
+ return false;
+ }
+ if (!os_version.is_valid()) {
+ return false;
+ }
+ if (!carrier.is_valid()) {
+ return false;
+ }
+ if (!user_consent_records.is_valid()) {
+ return false;
+ }
+ if (!max_number_rfcom_ports.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool DeviceParams::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool DeviceParams::struct_empty() const {
+ if (hardware.is_initialized()) {
+ return false;
+ }
+ if (firmware_rev.is_initialized()) {
+ return false;
+ }
+
+ if (os.is_initialized()) {
+ return false;
+ }
+ if (os_version.is_initialized()) {
+ return false;
+ }
+
+ if (carrier.is_initialized()) {
+ return false;
+ }
+ if (user_consent_records.is_initialized()) {
+ return false;
+ }
+
+ if (max_number_rfcom_ports.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void DeviceParams::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!hardware.is_valid()) {
+ hardware.ReportErrors(&report__->ReportSubobject("hardware"));
+ }
+ if (!firmware_rev.is_valid()) {
+ firmware_rev.ReportErrors(&report__->ReportSubobject("firmware_rev"));
+ }
+ if (!os.is_valid()) {
+ os.ReportErrors(&report__->ReportSubobject("os"));
+ }
+ if (!os_version.is_valid()) {
+ os_version.ReportErrors(&report__->ReportSubobject("os_version"));
+ }
+ if (!carrier.is_valid()) {
+ carrier.ReportErrors(&report__->ReportSubobject("carrier"));
+ }
+ if (!user_consent_records.is_valid()) {
+ user_consent_records.ReportErrors(&report__->ReportSubobject("user_consent_records"));
+ }
+ if (!max_number_rfcom_ports.is_valid()) {
+ max_number_rfcom_ports.ReportErrors(&report__->ReportSubobject("max_number_rfcom_ports"));
+ }
+}
+
+// PolicyTable methods
+PolicyTable::PolicyTable()
+ : CompositeType(kUninitialized) {
+}
+PolicyTable::PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config)
+ : CompositeType(kUninitialized),
+ app_policies(app_policies),
+ functional_groupings(functional_groupings),
+ consumer_friendly_messages(consumer_friendly_messages),
+ module_config(module_config) {
+}
+PolicyTable::~PolicyTable() {
+}
+PolicyTable::PolicyTable(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ app_policies(impl::ValueMember(value__, "app_policies")),
+ functional_groupings(impl::ValueMember(value__, "functional_groupings")),
+ consumer_friendly_messages(impl::ValueMember(value__, "consumer_friendly_messages")),
+ module_config(impl::ValueMember(value__, "module_config")),
+ module_meta(impl::ValueMember(value__, "module_meta")),
+ usage_and_error_counts(impl::ValueMember(value__, "usage_and_error_counts")),
+ device_data(impl::ValueMember(value__, "device_data")) {
+}
+Json::Value PolicyTable::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("app_policies", app_policies, &result__);
+ impl::WriteJsonField("functional_groupings", functional_groupings, &result__);
+ impl::WriteJsonField("consumer_friendly_messages", consumer_friendly_messages, &result__);
+ impl::WriteJsonField("module_config", module_config, &result__);
+ impl::WriteJsonField("module_meta", module_meta, &result__);
+ impl::WriteJsonField("usage_and_error_counts", usage_and_error_counts, &result__);
+ impl::WriteJsonField("device_data", device_data, &result__);
+ return result__;
+}
+bool PolicyTable::is_valid() const {
+ if (!app_policies.is_valid()) {
+ return false;
+ }
+ if (!functional_groupings.is_valid()) {
+ return false;
+ }
+ if (!consumer_friendly_messages.is_valid()) {
+ return false;
+ }
+ if (!module_config.is_valid()) {
+ return false;
+ }
+ if (!module_meta.is_valid()) {
+ return false;
+ }
+ if (!usage_and_error_counts.is_valid()) {
+ return false;
+ }
+ if (!device_data.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool PolicyTable::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool PolicyTable::struct_empty() const {
+ if (app_policies.is_initialized()) {
+ return false;
+ }
+ if (functional_groupings.is_initialized()) {
+ return false;
+ }
+
+ if (consumer_friendly_messages.is_initialized()) {
+ return false;
+ }
+ if (module_config.is_initialized()) {
+ return false;
+ }
+
+ if (module_meta.is_initialized()) {
+ return false;
+ }
+ if (usage_and_error_counts.is_initialized()) {
+ return false;
+ }
+
+ if (device_data.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void PolicyTable::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!app_policies.is_valid()) {
+ app_policies.ReportErrors(&report__->ReportSubobject("app_policies"));
+ }
+ if (!functional_groupings.is_valid()) {
+ functional_groupings.ReportErrors(&report__->ReportSubobject("functional_groupings"));
+ }
+ if (!consumer_friendly_messages.is_valid()) {
+ consumer_friendly_messages.ReportErrors(&report__->ReportSubobject("consumer_friendly_messages"));
+ }
+ if (!module_config.is_valid()) {
+ module_config.ReportErrors(&report__->ReportSubobject("module_config"));
+ }
+ if (!module_meta.is_valid()) {
+ module_meta.ReportErrors(&report__->ReportSubobject("module_meta"));
+ }
+ if (!usage_and_error_counts.is_valid()) {
+ usage_and_error_counts.ReportErrors(&report__->ReportSubobject("usage_and_error_counts"));
+ }
+ if (!device_data.is_valid()) {
+ device_data.ReportErrors(&report__->ReportSubobject("device_data"));
+ }
+}
+
+// Table methods
+Table::Table()
+ : CompositeType(kUninitialized) {
+}
+Table::Table(const PolicyTable& policy_table)
+ : CompositeType(kUninitialized),
+ policy_table(policy_table) {
+}
+Table::~Table() {
+}
+Table::Table(const Json::Value* value__)
+ : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+ policy_table(impl::ValueMember(value__, "policy_table")) {
+}
+Json::Value Table::ToJsonValue() const {
+ Json::Value result__(Json::objectValue);
+ impl::WriteJsonField("policy_table", policy_table, &result__);
+ return result__;
+}
+bool Table::is_valid() const {
+ if (!policy_table.is_valid()) {
+ return false;
+ }
+ return Validate();
+}
+bool Table::is_initialized() const {
+ return (initialization_state__ != kUninitialized) || (!struct_empty());
+}
+bool Table::struct_empty() const {
+ if (policy_table.is_initialized()) {
+ return false;
+ }
+ return true;
+}
+void Table::ReportErrors(rpc::ValidationReport* report__) const {
+ if (struct_empty()) {
+ rpc::CompositeType::ReportErrors(report__);
+ }
+ if (!policy_table.is_valid()) {
+ policy_table.ReportErrors(&report__->ReportSubobject("policy_table"));
+ }
+}
+
+} // namespace policy_table_interface_base
+} // namespace rpc
+
--- /dev/null
+// This file is generated, do not edit
+#ifndef POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_TYPES_H_
+#define POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_TYPES_H_
+#include "./enums.h"
+#include "./types.h"
+#include "rpc_base/rpc_message.h"
+namespace Json {
+class Value;
+} // namespace Json
+namespace rpc {
+namespace policy_table_interface_base {
+struct AppLevel;
+struct ApplicationParams;
+struct ConsentRecords;
+struct DeviceParams;
+struct MessageLanguages;
+struct MessageString;
+struct RpcParameters;
+struct Rpcs;
+} // namespace policy_table_interface_base
+} // namespace rpc
+
+
+namespace rpc {
+namespace policy_table_interface_base {
+
+typedef Array< String<1, 255>, 0, 255 > Strings;
+
+typedef Array< Enum<AppHMIType>, 0, 255 > AppHMITypes;
+
+typedef Array< Enum<HmiLevel>, 0, 4 > HmiLevels;
+
+typedef Array< Enum<Parameter>, 0, 24 > Parameters;
+
+typedef Map< RpcParameters, 0, 50 > Rpc;
+
+typedef Array< String<10, 255>, 1, 255 > URL;
+
+typedef Map< URL, 1, 255 > URLList;
+
+typedef Map< URLList, 1, 255 > ServiceEndpoints;
+
+typedef Map< Integer<uint8_t, 0, 255>, 0, 6 > NumberOfNotificationsPerMinute;
+
+typedef Array< Integer<uint16_t, 1, 1000>, 0, 10 > SecondsBetweenRetries;
+
+typedef Map< MessageString, 0, 500 > Languages;
+
+typedef Map< MessageLanguages, 0, 255 > Messages;
+
+typedef Map< AppLevel, 0, 255 > AppLevels;
+
+typedef Map< Boolean, 0, 255 > ConsentGroups;
+
+typedef Map< ConsentRecords, 0, 1000 > UserConsentRecords;
+
+typedef Map< Stringifyable < Nullable< ApplicationParams > >, 1, 1000 > ApplicationPolicies;
+
+typedef Map< Rpcs, 1, 255 > FunctionalGroupings;
+
+typedef Map< DeviceParams, 0, 255 > DeviceData;
+
+struct ApplicationParams : CompositeType {
+ public:
+ Strings groups;
+ Optional< Strings > nicknames;
+ Optional< Strings > preconsented_groups;
+ Optional< AppHMITypes > AppHMIType;
+ Enum<Priority> priority;
+ Enum<HmiLevel> default_hmi;
+ Boolean keep_context;
+ Boolean steal_focus;
+ Optional< Integer<uint16_t, 1, 65225> > memory_kb;
+ Optional< Integer<uint16_t, 1, 65225> > heart_beat_timeout_ms;
+ Optional< String<0, 255> > certificate;
+ public:
+ ApplicationParams();
+ ApplicationParams(const Strings& groups, Priority priority, HmiLevel default_hmi, bool keep_context, bool steal_focus);
+ ~ApplicationParams();
+ explicit ApplicationParams(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct RpcParameters : CompositeType {
+ public:
+ HmiLevels hmi_levels;
+ Optional< Parameters > parameters;
+ public:
+ RpcParameters();
+ explicit RpcParameters(const HmiLevels& hmi_levels);
+ ~RpcParameters();
+ explicit RpcParameters(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct Rpcs : CompositeType {
+ public:
+ Optional< String<1, 255> > user_consent_prompt;
+ Nullable< Rpc > rpcs;
+ public:
+ Rpcs();
+ explicit Rpcs(const Rpc& rpcs);
+ ~Rpcs();
+ explicit Rpcs(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ModuleConfig : CompositeType {
+ public:
+ Optional< Map< String<1, 100>, 1, 255 > > device_certificates;
+ Optional< Boolean > preloaded_pt;
+ Integer<uint8_t, 0, 255> exchange_after_x_ignition_cycles;
+ Integer<int64_t, 0, 4294967296> exchange_after_x_kilometers;
+ Integer<uint8_t, 0, 255> exchange_after_x_days;
+ Integer<uint16_t, 0, 65535> timeout_after_x_seconds;
+ SecondsBetweenRetries seconds_between_retries;
+ ServiceEndpoints endpoints;
+ NumberOfNotificationsPerMinute notifications_per_minute_by_priority;
+ Optional< String<1, 100> > vehicle_make;
+ Optional< String<1, 100> > vehicle_model;
+ Optional< String<4, 4> > vehicle_year;
+ public:
+ ModuleConfig();
+ ModuleConfig(uint8_t exchange_after_x_ignition_cycles, int64_t exchange_after_x_kilometers, uint8_t exchange_after_x_days, uint16_t timeout_after_x_seconds, const SecondsBetweenRetries& seconds_between_retries, const ServiceEndpoints& endpoints, const NumberOfNotificationsPerMinute& notifications_per_minute_by_priority);
+ ~ModuleConfig();
+ explicit ModuleConfig(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct MessageString : CompositeType {
+ public:
+ Optional< String<1, 255> > line1;
+ Optional< String<1, 255> > line2;
+ Optional< String<1, 65535> > tts;
+ Optional< String<1, 255> > label;
+ Optional< String<1, 500> > textBody;
+ public:
+ MessageString();
+ ~MessageString();
+ explicit MessageString(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct MessageLanguages : CompositeType {
+ public:
+ Languages languages;
+ public:
+ MessageLanguages();
+ explicit MessageLanguages(const Languages& languages);
+ ~MessageLanguages();
+ explicit MessageLanguages(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ConsumerFriendlyMessages : CompositeType {
+ public:
+ String<1, 100> version;
+ Optional< Messages > messages;
+ public:
+ ConsumerFriendlyMessages();
+ explicit ConsumerFriendlyMessages(const std::string& version);
+ ~ConsumerFriendlyMessages();
+ explicit ConsumerFriendlyMessages(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ModuleMeta : CompositeType {
+ public:
+ Optional< String<1, 250> > ccpu_version;
+ Optional< String<1, 250> > language;
+ Optional< String<1, 250> > wers_country_code;
+ Optional< Integer<uint16_t, 0, 65535> > pt_exchanged_at_odometer_x;
+ Optional< Integer<uint16_t, 0, 65535> > pt_exchanged_x_days_after_epoch;
+ Optional< Integer<uint16_t, 0, 65535> > ignition_cycles_since_last_exchange;
+ Optional< String<1, 250> > vin;
+ public:
+ ModuleMeta();
+ ~ModuleMeta();
+ explicit ModuleMeta(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct AppLevel : CompositeType {
+ public:
+ Integer<uint16_t, 0, 65535> minutes_in_hmi_full;
+ String<1, 10> app_registration_language_gui;
+ String<1, 10> app_registration_language_vui;
+ Integer<uint16_t, 0, 65535> count_of_rfcom_limit_reached;
+ Integer<uint16_t, 0, 65535> minutes_in_hmi_limited;
+ Integer<uint16_t, 0, 65535> minutes_in_hmi_background;
+ Integer<uint16_t, 0, 65535> minutes_in_hmi_none;
+ Integer<uint16_t, 0, 65535> count_of_user_selections;
+ Integer<uint16_t, 0, 65535> count_of_rejections_sync_out_of_memory;
+ Integer<uint16_t, 0, 65535> count_of_rejections_nickname_mismatch;
+ Integer<uint16_t, 0, 65535> count_of_rejections_duplicate_name;
+ Integer<uint16_t, 0, 65535> count_of_rejected_rpc_calls;
+ Integer<uint16_t, 0, 65535> count_of_rpcs_sent_in_hmi_none;
+ Integer<uint16_t, 0, 65535> count_of_removals_for_bad_behavior;
+ Integer<uint16_t, 0, 65535> count_of_run_attempts_while_revoked;
+ public:
+ AppLevel();
+ AppLevel(uint16_t minutes_in_hmi_full, const std::string& app_registration_language_gui, const std::string& app_registration_language_vui, uint16_t count_of_rfcom_limit_reached, uint16_t minutes_in_hmi_limited, uint16_t minutes_in_hmi_background, uint16_t minutes_in_hmi_none, uint16_t count_of_user_selections, uint16_t count_of_rejections_sync_out_of_memory, uint16_t count_of_rejections_nickname_mismatch, uint16_t count_of_rejections_duplicate_name, uint16_t count_of_rejected_rpc_calls, uint16_t count_of_rpcs_sent_in_hmi_none, uint16_t count_of_removals_for_bad_behavior, uint16_t count_of_run_attempts_while_revoked);
+ ~AppLevel();
+ explicit AppLevel(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct UsageAndErrorCounts : CompositeType {
+ public:
+ Optional< Integer<uint16_t, 0, 65535> > count_of_iap_buffer_full;
+ Optional< Integer<uint16_t, 0, 65535> > count_sync_out_of_memory;
+ Optional< Integer<uint16_t, 0, 65535> > count_of_sync_reboots;
+ Optional< AppLevels > app_level;
+ public:
+ UsageAndErrorCounts();
+ ~UsageAndErrorCounts();
+ explicit UsageAndErrorCounts(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct ConsentRecords : CompositeType {
+ public:
+ Optional< ConsentGroups > consent_groups;
+ Optional< Enum<Input> > input;
+ Optional< String<1, 255> > time_stamp;
+ public:
+ ConsentRecords();
+ ~ConsentRecords();
+ explicit ConsentRecords(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct DeviceParams : CompositeType {
+ public:
+ Optional< String<1, 255> > hardware;
+ Optional< Nullable< String<1, 255> > > firmware_rev;
+ Optional< String<1, 255> > os;
+ Optional< String<1, 255> > os_version;
+ Optional< Nullable< String<1, 255> > > carrier;
+ Optional< UserConsentRecords > user_consent_records;
+ Optional< Integer<uint8_t, 0, 255> > max_number_rfcom_ports;
+ public:
+ DeviceParams();
+ ~DeviceParams();
+ explicit DeviceParams(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct PolicyTable : CompositeType {
+ public:
+ ApplicationPolicies app_policies;
+ FunctionalGroupings functional_groupings;
+ Optional < ConsumerFriendlyMessages > consumer_friendly_messages;
+ ModuleConfig module_config;
+ Optional< ModuleMeta > module_meta;
+ Optional< UsageAndErrorCounts > usage_and_error_counts;
+ Optional< DeviceData > device_data;
+ public:
+ PolicyTable();
+ PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config);
+ ~PolicyTable();
+ explicit PolicyTable(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+
+struct Table : CompositeType {
+ public:
+ PolicyTable policy_table;
+ public:
+ Table();
+ explicit Table(const PolicyTable& policy_table);
+ ~Table();
+ explicit Table(const Json::Value* value__);
+ Json::Value ToJsonValue() const;
+ bool is_valid() const;
+ bool is_initialized() const;
+ bool struct_empty() const;
+ void ReportErrors(rpc::ValidationReport* report__) const;
+ private:
+ bool Validate() const;
+};
+} // namespace policy_table_interface_base
+} // namespace rpc
+
+#endif // POLICY_TABLE_INTERFACE_BASE_POLICY_TABLE_INTERFACE_BASE_TYPES_H_
--- /dev/null
+// This file is generated, do not edit
+#include "./types.h"
+
+namespace rpc {
+namespace policy_table_interface_base {
+bool ApplicationParams::Validate() const {
+ if (is_initialized()) {
+ if (preconsented_groups.is_initialized()) {
+ const Strings& all = groups;
+ const Strings& preconsented = *preconsented_groups;
+ if (preconsented.size() > all.size()) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+bool RpcParameters::Validate() const {
+ return true;
+}
+bool Rpcs::Validate() const {
+ return true;
+}
+bool ModuleConfig::Validate() const {
+ return true;
+}
+bool MessageString::Validate() const {
+ return true;
+}
+bool MessageLanguages::Validate() const {
+ return true;
+}
+bool ConsumerFriendlyMessages::Validate() const {
+ return true;
+}
+bool ModuleMeta::Validate() const {
+ return true;
+}
+bool AppLevel::Validate() const {
+ return true;
+}
+bool UsageAndErrorCounts::Validate() const {
+ return true;
+}
+bool ConsentRecords::Validate() const {
+ return true;
+}
+bool DeviceParams::Validate() const {
+ return true;
+}
+bool PolicyTable::Validate() const {
+ for (ApplicationPolicies::const_iterator it = app_policies.begin();
+ app_policies.end() != it; ++it) {
+ if (kDeviceApp == it->first) {
+ if (it->second.AppHMIType.is_initialized()
+ || it->second.memory_kb.is_initialized()
+ || it->second.heart_beat_timeout_ms.is_initialized()
+ || it->second.nicknames.is_initialized()) {
+ initialization_state__ = kUninitialized;
+ return false;
+ }
+ continue;
+ }
+ if (kDefaultApp == it->first || kPreDataConsentApp == it->first) {
+ if (!it->second.memory_kb.is_initialized()
+ || !it->second.heart_beat_timeout_ms.is_initialized()
+ || it->second.nicknames.is_initialized()) {
+ initialization_state__ = kUninitialized;
+ return false;
+ }
+ continue;
+ }
+ if (!it->second.is_null() && !it->second.is_string()
+ && (!it->second.nicknames.is_initialized()
+ || !it->second.AppHMIType.is_initialized()
+ || !it->second.memory_kb.is_initialized()
+ || !it->second.heart_beat_timeout_ms.is_initialized())) {
+ initialization_state__ = kUninitialized;
+ return false;
+ }
+ }
+ if (consumer_friendly_messages.is_initialized()) {
+ if (!(*consumer_friendly_messages).messages.is_initialized()) {
+ return false;
+ }
+ }
+ return true;
+}
+bool Table::Validate() const {
+ return true;
+}
+} // namespace policy_table_interface_base
+} // namespace rpc
+
mandatory="false" />
<param name="vehicle_model" type="String" maxlength="100"
mandatory="false" />
- <param name="vehicle_year" type="Integer" minvalue="1900" maxvalue="2020"
+ <param name="vehicle_year" type="String" minlength="4" maxlength="4"
mandatory="false" />
</struct>
<!-- module_config section end -->
<struct name="Rpcs">
<param name="user_consent_prompt" type="String" minlegth="1"
maxlength="255" mandatory="false"/>
- <param name="rpcs" type="Rpc" />
+ <param name="rpcs" type="Rpc" null_values_allowed="true"/>
</struct>
<!-- app_policies section end -->
mandatory="false" />
<param name="vehicle_model" type="String" maxlength="100"
mandatory="false" />
- <param name="vehicle_year" type="Integer" minvalue="1900" maxvalue="2020"
+ <param name="vehicle_year" type="String" minlength="4" maxlength="4"
mandatory="false" />
</struct>
<!-- module_config section end -->
}
int SQLQuery::GetInteger(int pos) const {
- return *static_cast<int*>(qdb_cell(result_, current_row_, pos));
+ return rows_ == 0 ? 0 :
+ *static_cast<int*>(qdb_cell(result_, current_row_, pos));
}
double SQLQuery::GetDouble(int pos) const {
- return *static_cast<double*>(qdb_cell(result_, current_row_, pos));
+ return rows_ == 0 ? 0 :
+ *static_cast<double*>(qdb_cell(result_, current_row_, pos));
}
std::string SQLQuery::GetString(int pos) const {
+ if (rows_ == 0) {
+ return "";
+ }
void* str = qdb_cell(result_, current_row_, pos);
return str ? static_cast<const char*>(str) : "";
}
bool SQLQuery::IsNull(int pos) const {
- return qdb_cell_type(result_, current_row_, pos) == QDB_NULL;
+ return rows_ == 0 || qdb_cell_type(result_, current_row_, pos) == QDB_NULL;
}
const std::string& SQLQuery::query() const {
)
add_library(${target} ${SOURCES})
-target_link_libraries(${target} sqlite3 Utils)
\ No newline at end of file
+target_link_libraries(${target} Utils)
bool CheckAppPolicy::HasSameGroups(const AppPoliciesValueType& app_policy,
AppPermissions* perms) const {
- policy_table::Strings groups_new = app_policy.second.groups;
- std::sort(groups_new.begin(), groups_new.end(), Compare);
const std::string app_id = app_policy.first;
AppPoliciesConstItr it = pm_->policy_table_snapshot_->policy_table
.app_policies.find(app_id);
+
+ if (app_policy.second.is_string()) {
+ return (it->second.is_string() &&
+ app_policy.second.get_string().compare(it->second.get_string()) == 0);
+ } else {
+ if (it->second.is_string()) {
+ return false;
+ }
+ }
+
+ policy_table::Strings groups_new = app_policy.second.groups;
+ std::sort(groups_new.begin(), groups_new.end(), Compare);
+
policy_table::Strings groups_curr = (*it).second.groups;
std::sort(groups_curr.begin(), groups_curr.end(), Compare);
SendOnPendingPermissions(app_policy, permissions_diff);
}
- // TODO(PV): if 'device' was update with new/other func groups => user consent for device should be cleared.
+ // if 'device' was update with new/other func groups => user consent
+ // for device should be cleared.
+ if (kDeviceId == app_id) {
+#if defined (EXTENDED_POLICY)
+ // TODO(AOleynik): Check design for more convenient access to policy ext data
+ PTExtRepresentation* pt_ext = dynamic_cast<PTExtRepresentation*>(pm_->policy_table_
+ .pt_data().get());
+ if (pt_ext) {
+ if (!pt_ext->ResetDeviceConsents()) {
+ return false;
+ }
+ }
+#endif
+ }
return true;
}
#include <algorithm>
#include <set>
+#include <iterator>
#include "json/reader.h"
#include "json/writer.h"
#include "policy/policy_table.h"
bool PolicyManagerImpl::LoadPTFromFile(const std::string& file_name) {
LOG4CXX_INFO(logger_, "LoadPTFromFile: " << file_name);
+
+ BinaryMessage json_string;
bool final_result = false;
- InitResult init_result = policy_table_.pt_data()->Init();
- switch (init_result) {
- case InitResult::EXISTS: {
- LOG4CXX_INFO(logger_, "Policy Table exists, was loaded correctly.");
- final_result = true;
- break;
- }
- case InitResult::SUCCESS: {
- BinaryMessage json_string;
- final_result = file_system::ReadBinaryFile(file_name, json_string);
- if (!final_result) {
- LOG4CXX_WARN(logger_, "Failed to read pt file.");
- utils::SharedPtr<policy_table::Table> table = new policy_table::Table();
- return final_result;
- }
- utils::SharedPtr<policy_table::Table> table = Parse(json_string);
- if (!table) {
- LOG4CXX_WARN(logger_, "Failed to parse policy table");
- utils::SharedPtr<policy_table::Table> table = new policy_table::Table();
- return false;
- }
- final_result = final_result && policy_table_.pt_data()->Save(*table);
- LOG4CXX_INFO(
- logger_,
- "Loading from file was " << (final_result ? "successful" : "unsuccessful"));
- }
- break;
- case InitResult::FAIL:
- default: {
- LOG4CXX_WARN(logger_, "Failed to init policy table.");
- return final_result;
- }
+ final_result = file_system::ReadBinaryFile(file_name, json_string);
+ if (!final_result) {
+ LOG4CXX_WARN(logger_, "Failed to read pt file.");
+ utils::SharedPtr<policy_table::Table> table = new policy_table::Table();
+ return final_result;
}
+ utils::SharedPtr<policy_table::Table> table = Parse(json_string);
+ if (!table) {
+ LOG4CXX_WARN(logger_, "Failed to parse policy table");
+ utils::SharedPtr<policy_table::Table> table = new policy_table::Table();
+ return false;
+ }
+ final_result = final_result && policy_table_.pt_data()->Save(*table);
+ LOG4CXX_INFO(
+ logger_,
+ "Loading from file was " << (final_result ? "successful" : "unsuccessful"));
// Initial setting of snapshot data
- if (!policy_table_snapshot_.valid()) {
+ if (!policy_table_snapshot_) {
policy_table_snapshot_ = policy_table_.pt_data()->GenerateSnapshot();
- if (!policy_table_snapshot_.valid()) {
+ if (!policy_table_snapshot_) {
LOG4CXX_WARN(logger_,
"Failed to create initial snapshot of policy table");
return final_result;
if (reader.parse(json.c_str(), value)) {
return new policy_table::Table(&value);
} else {
- return 0;
+ return utils::SharedPtr<policy_table::Table>();
}
}
.module_config;
bool is_message_part_updated = pt_update->policy_table
- .consumer_friendly_messages.messages.is_initialized();
+ .consumer_friendly_messages.is_initialized();
if (is_message_part_updated) {
- policy_table_snapshot_->policy_table.consumer_friendly_messages.messages =
- pt_update->policy_table.consumer_friendly_messages.messages;
+ policy_table_snapshot_->policy_table.consumer_friendly_messages->messages =
+ pt_update->policy_table.consumer_friendly_messages->messages;
}
//policy_table.module_meta
return NULL;
}
- if (!exchange_pending_) {
- set_update_required(false);
- }
-
- set_exchange_in_progress(true);
- set_exchange_pending(false);
-
- Json::Value value = policy_table_snapshot_->ToJsonValue();
-
policy_table::ApplicationPolicies& apps = policy_table_snapshot_->policy_table.app_policies;
std::map<std::string,
- rpc::Nullable<rpc::policy_table_interface_base::ApplicationParams>>::iterator it = apps.begin();
+ rpc::Stringifyable<rpc::Nullable<rpc::policy_table_interface_base::ApplicationParams>>>::iterator it = apps.begin();
for (; apps.end() != it; ++it) {
if (policy_table_.pt_data()->IsDefaultPolicy(it->first)) {
- printf("\n\t\t\t\tDefault policy of %s\n", it->first.c_str());
- value["policy_table"]["app_policies"][it->first] = kDefaultId;
+ it->second.set_to_string(kDefaultId);
continue;
}
if (policy_table_.pt_data()->IsPredataPolicy(it->first)) {
- printf("\n\t\t\t\tPredata policy of %s\n", it->first.c_str());
- value["policy_table"]["app_policies"][it->first] = kPreDataConsentId;
+ it->second.set_to_string(kPreDataConsentId);
continue;
}
- Json::Value app_value = it->second.ToJsonValue();
- value["policy_table"]["app_policies"][it->first] = app_value;
}
+ if (!exchange_pending_) {
+ set_update_required(false);
+ }
+
+ set_exchange_in_progress(true);
+ set_exchange_pending(false);
+
+#ifdef EXTENDED_POLICY
+ // TODO(KKolodiy): Check design for more convenient access to policy ext data
+ PTExtRepresentation* pt_ext = dynamic_cast<PTExtRepresentation*>(policy_table_
+ .pt_data().get());
+ if (pt_ext) {
+ pt_ext->UnpairedDevicesList(&unpaired_device_ids_);
+ }
+#endif // EXTENDED_POLICY
+
+ Json::Value value = policy_table_snapshot_->ToJsonValue();
Json::FastWriter writer;
std::string message_string = writer.write(value);
- LOG4CXX_INFO(logger_, "\n\n\n\nPT Snapshot " << message_string << "\n\n\n");
return new BinaryMessage(message_string.begin(), message_string.end());
}
result.list_of_allowed_params = new std::vector<PTString>();
std::copy(rpc_permissions[rpc].parameter_permissions[kAllowedKey].begin(),
rpc_permissions[rpc].parameter_permissions[kAllowedKey].end(),
- result.list_of_allowed_params->begin());
+ std::back_inserter(*result.list_of_allowed_params));
return result;
#else
default_hmi);
}
-bool PolicyManagerImpl::CleanupUnpairedDevices(const DeviceIds& device_ids) {
+bool PolicyManagerImpl::CleanupUnpairedDevices() {
LOG4CXX_INFO(logger_, "CleanupUnpairedDevices");
-#if defined (EXTENDED_POLICY)
+#ifdef EXTENDED_POLICY
PTExtRepresentation* pt_ext = dynamic_cast<PTExtRepresentation*>(policy_table_
.pt_data().get());
if (!pt_ext) {
return false;
}
- return pt_ext->CleanupUnpairedDevices(device_ids);
-#else
- return policy_table_.pt_data()->CleanupUnpairedDevices(device_ids);
-#endif
+ return pt_ext->CleanupUnpairedDevices(unpaired_device_ids_);
+#else // EXTENDED_POLICY
+ // For SDL-specific it doesn't matter
+ return true;
+#endif // EXTENDED_POLICY
}
PolicyTableStatus PolicyManagerImpl::GetPolicyTableStatus() {
return policy_table_.pt_data()->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_, "GetUserPermissionsForApp");
+#if defined (EXTENDED_POLICY)
+ // TODO(KKolodiy): Check design for more convenient access to policy ext data
+ PTExtRepresentation* pt_ext = dynamic_cast<PTExtRepresentation*>(policy_table_
+ .pt_data().get());
+ if (pt_ext) {
+ FunctionalIdType group_types;
+ if (!pt_ext->GetUserPermissionsForApp(device_id, policy_app_id,
+ &group_types)) {
+ LOG4CXX_WARN(logger_, "Can't get user permissions for app "
+ << policy_app_id);
+ return;
+ }
+
+ FunctionalGroupIDs all_groups = group_types[kTypeGeneral];
+ FunctionalGroupIDs preconsented_groups = group_types[kTypePreconsented];
+ FunctionalGroupIDs consent_allowed_groups = group_types[kTypeAllowed];
+ FunctionalGroupIDs consent_disallowed_groups = group_types[kTypeDisallowed];
+ FunctionalGroupIDs default_groups = group_types[kTypeDefault];
+ FunctionalGroupIDs predataconsented_groups =
+ group_types[kTypePreDataConsented];
+ FunctionalGroupIDs device_groups = group_types[kTypeDevice];
+
+ std::sort(all_groups.begin(), all_groups.end());
+ std::sort(preconsented_groups.begin(), preconsented_groups.end());
+ std::sort(consent_allowed_groups.begin(), consent_allowed_groups.end());
+ std::sort(consent_disallowed_groups.begin(), consent_disallowed_groups.end());
+ std::sort(default_groups.begin(), default_groups.end());
+ std::sort(predataconsented_groups.begin(), predataconsented_groups.end());
+ std::sort(device_groups.begin(), device_groups.end());
+
+ FunctionalGroupIDs allowed_preconsented;
+ std::set_difference(preconsented_groups.begin(), preconsented_groups.end(),
+ consent_disallowed_groups.begin(),
+ consent_disallowed_groups.end(),
+ std::back_inserter(allowed_preconsented));
+ FunctionalGroupIDs allowed_groups;
+ std::set_union(consent_allowed_groups.begin(), consent_allowed_groups.end(),
+ allowed_preconsented.begin(), allowed_preconsented.end(),
+ std::back_inserter(allowed_groups));
+
+ FunctionalGroupIDs first_excluded_groups;
+ std::set_union(default_groups.begin(), default_groups.end(),
+ predataconsented_groups.begin(), predataconsented_groups.end(),
+ std::back_inserter(first_excluded_groups));
+ FunctionalGroupIDs excluded_groups;
+ std::set_union(first_excluded_groups.begin(), first_excluded_groups.end(),
+ device_groups.begin(), device_groups.end(),
+ std::back_inserter(excluded_groups));
+
+ FunctionalGroupIDs only_needed_groups;
+ std::set_difference(all_groups.begin(), all_groups.end(),
+ excluded_groups.begin(), excluded_groups.end(),
+ std::back_inserter(only_needed_groups));
+ FunctionalGroupIDs no_disallowed_groups;
+ std::set_difference(only_needed_groups.begin(), only_needed_groups.end(),
+ consent_disallowed_groups.begin(),
+ consent_disallowed_groups.end(),
+ std::back_inserter(no_disallowed_groups));
+ FunctionalGroupIDs undefined_consent;
+ std::set_difference(no_disallowed_groups.begin(), no_disallowed_groups.end(),
+ allowed_groups.begin(), allowed_groups.end(),
+ std::back_inserter(undefined_consent));
+
+ FunctionalGroupNames group_names;
+ if (!pt_ext->GetFunctionalGroupNames(group_names)) {
+ LOG4CXX_WARN(logger_, "Can't get functional group names");
+ return;
+ }
+
+ // Fill result
+ FillFunctionalGroupPermissions(undefined_consent, group_names,
+ kGroupUndefined, permissions);
+ FillFunctionalGroupPermissions(allowed_groups, group_names,
+ kGroupAllowed, permissions);
+ FillFunctionalGroupPermissions(consent_disallowed_groups, group_names,
+ kGroupDisallowed, permissions);
+ }
+#else
+ // For basic policy
+ permissions = std::vector<FunctionalGroupPermission>();
+#endif
+}
+
void PolicyManagerImpl::GetUserPermissionsForApp(
const std::string& device_id, const std::string& policy_app_id,
std::vector<FunctionalGroupPermission>& permissions) {
#if defined (EXTENDED_POLICY)
PTExtRepresentation* pt_ext = dynamic_cast<PTExtRepresentation*>(policy_table_
.pt_data().get());
+ const std::string device_id = GetCurrentDeviceId(app_id);
int count = 0;
- if (pt_ext->CountUnconsentedGroups(app_id, &count)) {
+ if (pt_ext->CountUnconsentedGroups(app_id, device_id, &count)) {
return count;
} else {
return 0;
#endif
}
+void PolicyManagerImpl::MarkUnpairedDevice(const std::string& device_id) {
+#ifdef EXTENDED_POLICY
+ // TODO(KKolodiy): Check design for more convenient access to policy ext data
+ PTExtRepresentation* pt_ext = dynamic_cast<PTExtRepresentation*>(policy_table_
+ .pt_data().get());
+ if (pt_ext) {
+ pt_ext->SetUnpairedDevice(device_id);
+ SetUserConsentForDevice(device_id, false);
+ }
+#endif // EXTENDED_POLICY
+}
+
+bool PolicyManagerImpl::ResetPT(const std::string& file_name) {
+ return policy_table_.pt_data()->Clear() && LoadPTFromFile(file_name);
+}
+
+bool PolicyManagerImpl::InitPT(const std::string& file_name) {
+ bool ret = false;
+ InitResult init_result = policy_table_.pt_data()->Init();
+ switch (init_result) {
+ case InitResult::EXISTS: {
+ LOG4CXX_INFO(logger_, "Policy Table exists, was loaded correctly.");
+ ret = true;
+ } break;
+ case InitResult::SUCCESS: {
+ LOG4CXX_INFO(logger_, "Policy Table was inited successfully");
+ ret = LoadPTFromFile(file_name);
+ } break;
+ case InitResult::FAIL:
+ default: {
+ LOG4CXX_ERROR(logger_, "Failed to init policy table.");
+ ret = false;
+ }
+ }
+ return ret;
+}
+
} // namespace policy
const std::string kSelectPriority =
"SELECT `priority_value` FROM `application` WHERE `id` = ? LIMIT 1";
-const std::string kResetUserConsent = "DELETE FROM `device_consent_group`";
+const std::string kResetDeviceConsents = "DELETE FROM `device_consent_group`";
+
+const std::string kResetAppConsents = "DELETE FROM `consent_group`";
const std::string kCountDeviceConsentGroup = "SELECT COUNT (`device_id`) "
"FROM `device_consent_group` WHERE `device_id` = ?";
const std::string kCountUnconsentedGroups =
"SELECT COUNT(`a`.`functional_group_id`) FROM `app_group` AS `a` "
- "JOIN `consent_group` AS `f` ON (`a`.`application_id` = `f`.`application_id`) "
- "JOIN `preconsented_group` AS `p` ON (`p`.`application_id` = `a`.`application_id`) "
- "WHERE `a`.`application_id` = ? AND NOT (`f`.`functional_group_id` = `a`.`functional_group_id`) "
- "AND NOT (`p`.`functional_group_id` = `a`.`functional_group_id`)";
-
-const std::string kSelectModuleMeta = "SELECT * FROM `module_meta`";
+ " WHERE `a`.`application_id` = ? AND NOT EXISTS "
+ " (SELECT NULL FROM `preconsented_group` AS `p` WHERE "
+ " (`p`.`functional_group_id` = `a`.`functional_group_id` AND "
+ " `p`.`application_id` = `a`.`application_id`)) "
+ " AND NOT EXISTS (SELECT NULL FROM `consent_group` AS `c` "
+ " WHERE (`c`.`application_id` = `a`.`application_id` "
+ " AND `c`.`functional_group_id` = `a`.`functional_group_id` "
+ " AND `c`.`device_id` = ?)) AND NOT EXISTS "
+ " (SELECT NULL FROM `app_group` AS `def` WHERE "
+ " (`def`.`application_id` = ? OR "
+ " `def`.`application_id` = ?) "
+ " AND `def`.`functional_group_id` = `a`.`functional_group_id`)";
+
+
+const std::string kSelectModuleMeta = "SELECT* FROM `module_meta`";
const std::string kUpdateMetaParams = "UPDATE `module_meta` SET "
"`ccpu_version` = ?, `wers_country_code` = ?, `language` = ? ";
const std::string kCountAppLevel =
"SELECT COUNT(`application_id`) FROM `app_level`"
- " WHERE `application_id` = ?";
+ " WHERE `application_id` = ? ";
const std::string kUpdateGroupPermissions =
"UPDATE `consent_group` "
"SET `is_consented` = ?, `input` = ? "
- "WHERE (`application_id` = ? AND `functional_group_id` = ? AND `device_id` = ?) ";
+ "WHERE(`application_id` = ? AND `functional_group_id` = ? AND `device_id` = ?) ";
const std::string kInsertApplication =
- "INSERT OR IGNORE INTO `application` (`id`, `keep_context`, `steal_focus`,"
- " `default_hmi`, `priority_value`, `is_revoked`, `memory_kb`,"
- " `watchdog_timer_ms`, `certificate`) VALUES (?,?,?,?,?,?,?,?,?) ";
+ "INSERT OR IGNORE INTO `application`(`id`, `keep_context`, `steal_focus`, "
+ " `default_hmi`, `priority_value`, `is_revoked`, `memory_kb`, "
+ " `heart_beat_timeout_ms`, `certificate`) VALUES( ?, ?, ?, ?, ?, ?, ?, ?, ?) ";
const std::string kSelectFriendlyMsg =
"SELECT `tts`, `label`, `line1`, `line2`, `textBody` FROM `message` "
const std::string kSelectConsentedGroupsId =
"SELECT `functional_group_id`, `is_consented` "
- "FROM `consent_group` WHERE (`application_id` = ? AND `device_id` = ?) ";
+ "FROM `consent_group` WHERE(`application_id` = ? AND `device_id` = ?) ";
-const std::string kCountAppConsents = "SELECT COUNT (*) from `consent_group`"
- "WHERE (`device_id` = ? AND `application_id` = ? AND "
+const std::string kCountAppConsents = "SELECT COUNT(*) from `consent_group`"
+ "WHERE(`device_id` = ? AND `application_id` = ? AND "
"`functional_group_id` = ?) ";
const std::string kSelectPreconsentedGroupsId = "SELECT `functional_group_id` "
"FROM `preconsented_group` WHERE `application_id` = ? ";
const std::string kSelectAppPolicies =
- "SELECT `id`, `priority_value`, `default_hmi`, `keep_context`, `steal_focus`,"
- " `memory_kb`, `watchdog_timer_ms`, `certificate` FROM `application`";
+ "SELECT `id`, `priority_value`, `default_hmi`, `keep_context`, `steal_focus`, "
+ " `memory_kb`, `heart_beat_timeout_ms`, `certificate` FROM `application`";
const std::string kSelectFunctionalGroupNames = "SELECT `id`, `user_consent_prompt`, `name`"
" FROM `functional_group`";
"WHERE `device_id` = ? ";
const std::string kSelectApplicationIsPreData =
- "SELECT `is_predata` FROM `application` WHERE `id` = ?";
+ "SELECT `is_predata` FROM `application` WHERE `id` = ? ";
const std::string kUpdateIsPredata =
- "UPDATE `application` SET `is_predata` = ? WHERE `id` = ?";
+ "UPDATE `application` SET `is_predata` = ? WHERE `id` = ? ";
const std::string kHasAppPreloadedGroups =
"SELECT COUNT(`a1`.`functional_group_id`) FROM `app_group` "
" ON `a1`.`functional_group_id` = `a2`.`functional_group_id` "
" WHERE `a1`.`application_id` = ? AND `a2`.`application_id` = ? ";
+const std::string kUpdateUnpairedDevice =
+ "UPDATE `device` SET `unpaired` = ? WHERE `id` = ? ";
+
+const std::string kSelectUnpairedDevices =
+ "SELECT `id` FROM `device` WHERE `unpaired` = 1";
} // namespace sql_pt_ext
} // namespace policy
}
bool SQLPTExtRepresentation::ResetUserConsent() {
- return dbms::SQLQuery(db()).Exec(sql_pt_ext::kResetUserConsent);
+ return ResetDeviceConsents() && ResetAppConsents();
+}
+
+bool SQLPTExtRepresentation::ResetDeviceConsents() {
+ dbms::SQLQuery query(db());
+ if (!query.Prepare(sql_pt_ext::kResetDeviceConsents)) {
+ LOG4CXX_WARN(logger_, "Incorrect delete statement from device_consents.");
+ return false;
+ }
+ return query.Exec();
+}
+
+bool SQLPTExtRepresentation::ResetAppConsents() {
+ return dbms::SQLQuery(db()).Exec(sql_pt_ext::kResetAppConsents);
}
bool SQLPTExtRepresentation::GetUserPermissionsForDevice(
return false;
}
+ // Get all default groups - they should always be allowed
+ FunctionalGroupIDs predataconsented_groups;
+ if (!GetAllAppGroups(kPreDataConsentId, predataconsented_groups)) {
+ return false;
+ }
+
+ // Get all default groups - they should always be allowed
+ FunctionalGroupIDs device_groups;
+ if (!GetAllAppGroups(kDeviceId, device_groups)) {
+ return false;
+ }
+
(*group_types)[kTypeDefault] = default_groups;
(*group_types)[kTypeAllowed] = allowed_groups;
(*group_types)[kTypeDisallowed] = disallowed_groups;
(*group_types)[kTypePreconsented] = preconsented_groups;
(*group_types)[kTypeGeneral] = all_groups;
+ (*group_types)[kTypePreDataConsented] = predataconsented_groups;
+ (*group_types)[kTypeDevice] = device_groups;
return true;
}
3, std::string(policy_table::EnumToJsonString(it->second.default_hmi)));
app_query.Bind(
4, std::string(policy_table::EnumToJsonString(it->second.priority)));
- printf("\n\t\t\t\tIs app Revoked: %s: %d\n", it->first.c_str(), it->second.is_null());
app_query.Bind(
5, it->second.is_null());
app_query.Bind(6, it->second.memory_kb);
- app_query.Bind(7, it->second.watchdog_timer_ms);
+ app_query.Bind(7, it->second.heart_beat_timeout_ms);
it->second.certificate.is_initialized() ?
app_query.Bind(8, *it->second.certificate) : app_query.Bind(8, std::string());
}
LOG4CXX_INFO(logger_, "Saving data for application: " << it->first);
+ if (it->second.is_string()) {
+ if (kDefaultId.compare(it->second.get_string()) == 0) {
+ if (!SetDefaultPolicy(it->first)) {
+ return false;
+ }
+ }
+ if (kPreDataConsentId.compare(it->second.get_string()) == 0) {
+ if (!SetPredataPolicy(it->first)) {
+ return false;
+ }
+ }
+ continue;
+ }
+
if (!SaveAppGroup(it->first, it->second.groups)) {
return false;
}
params.keep_context = query.GetBoolean(3);
params.steal_focus = query.GetBoolean(4);
*params.memory_kb = query.GetInteger(5);
- *params.watchdog_timer_ms = query.GetInteger(6);
+ *params.heart_beat_timeout_ms = query.GetInteger(6);
if (!query.IsNull(7)) {
*params.certificate = query.GetString(7);
}
}
bool SQLPTExtRepresentation::CountUnconsentedGroups(
- const std::string& policy_app_id, int* result) const {
+ const std::string& policy_app_id,
+ const std::string& device_id,
+ int* result) const {
LOG4CXX_INFO(logger_, "CountUnconsentedGroups");
dbms::SQLQuery query(db());
if (!query.Prepare(sql_pt_ext::kCountUnconsentedGroups)) {
}
query.Bind(0, policy_app_id);
+ query.Bind(1, device_id);
+ query.Bind(2, kDefaultId);
+ query.Bind(3, kPreDataConsentId);
if (!query.Exec()) {
LOG4CXX_INFO(logger_, "Error during executing unconsented groups.");
}
*result = query.GetInteger(0);
return true;
-
}
bool SQLPTExtRepresentation::SaveMessageString(
}
bool SQLPTExtRepresentation::CleanupUnpairedDevices(
- const DeviceIds& device_ids) {
+ const DeviceIds& device_ids) const {
LOG4CXX_INFO(logger_, "CleanupUnpairedDevices");
dbms::SQLQuery delete_device_query(db());
if (!delete_device_query.Prepare(sql_pt::kDeleteDevice)) {
return true;
}
+bool SQLPTExtRepresentation::SetUnpairedDevice(const std::string& device_id) const {
+ LOG4CXX_TRACE(logger_, "Set unpaired device: " << device_id);
+ dbms::SQLQuery query(db());
+ if (!query.Prepare(sql_pt_ext::kUpdateUnpairedDevice)) {
+ LOG4CXX_WARN(logger_, "Incorect statement for updating unpaired device");
+ return false;
+ }
+
+ query.Bind(0, true);
+ query.Bind(1, device_id);
+ if (!query.Exec()) {
+ LOG4CXX_WARN(logger_, "Failed update unpaired device");
+ return false;
+ }
+ return true;
+}
+
+bool SQLPTExtRepresentation::UnpairedDevicesList(DeviceIds* device_ids) const {
+ LOG4CXX_TRACE(logger_, "Get list of unpaired devices");
+ dbms::SQLQuery query(db());
+ if (!query.Prepare(sql_pt_ext::kSelectUnpairedDevices)) {
+ LOG4CXX_WARN(logger_, "Incorect statement for selecting unpaired devices");
+ return false;
+ }
+
+ while (query.Next()) {
+ device_ids->push_back(query.GetString(0));
+ }
+ return true;
+}
+
} // namespace policy
" `os` VARCHAR(45), "
" `os_version` VARCHAR(45), "
" `carrier` VARCHAR(45), "
- " `max_number_rfcom_ports` INTEGER "
+ " `max_number_rfcom_ports` INTEGER,"
+ " `unpaired` BOOL "
"); "
"CREATE TABLE IF NOT EXISTS `usage_and_error_count`( "
" `count_of_iap_buffer_full` INTEGER, "
" `count_sync_out_of_memory` INTEGER, "
" `count_of_sync_reboots` INTEGER "
"); "
- "INSERT OR IGNORE INTO `usage_and_error_count` ( "
- " `count_of_iap_buffer_full`, `count_sync_out_of_memory`, "
- " `count_of_sync_reboots`) VALUES (0, 0, 0); "
"CREATE TABLE IF NOT EXISTS `module_meta`( "
" `ccpu_version` VARCHAR(45), "
" `language` VARCHAR(45), "
" `vin` VARCHAR(45),"
" `flag_update_required` BOOL NOT NULL "
"); "
- "INSERT OR IGNORE INTO `module_meta` (`pt_exchanged_at_odometer_x`, "
- " `pt_exchanged_x_days_after_epoch`, `ignition_cycles_since_last_exchange`,"
- " `flag_update_required`) "
- " VALUES (0, 0, 0, 0); "
"CREATE TABLE IF NOT EXISTS `module_config`( "
" `preloaded_pt` BOOL NOT NULL, "
" `exchange_after_x_ignition_cycles` INTEGER NOT NULL, "
" `timeout_after_x_seconds` INTEGER NOT NULL, "
" `vehicle_make` VARCHAR(45), "
" `vehicle_model` VARCHAR(45), "
- " `vehicle_year` INTEGER "
+ " `vehicle_year` VARCHAR(4) "
"); "
- "INSERT OR IGNORE INTO `module_config` (`preloaded_pt`, "
- " `exchange_after_x_ignition_cycles`, `exchange_after_x_kilometers`, "
- " `exchange_after_x_days`, `timeout_after_x_seconds`) "
- " VALUES(1, 0, 0, 0, 0); "
"CREATE TABLE IF NOT EXISTS `functional_group`( "
" `id` INTEGER PRIMARY KEY NOT NULL, "
" `user_consent_prompt` TEXT UNIQUE ON CONFLICT REPLACE, "
"CREATE TABLE IF NOT EXISTS `priority`( "
" `value` VARCHAR(45) PRIMARY KEY NOT NULL "
"); "
- "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('EMERGENCY');"
- "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NAVIGATION');"
- "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('VOICECOMMUNICATION');"
- "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('COMMUNICATION');"
- "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NORMAL');"
- "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NONE');"
"CREATE TABLE IF NOT EXISTS `hmi_level`( "
" `value` VARCHAR(45) PRIMARY KEY NOT NULL "
"); "
- "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('FULL');"
- "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('LIMITED');"
- "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('BACKGROUND');"
- "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('NONE');"
"CREATE TABLE IF NOT EXISTS `notifications_by_priority`( "
" `priority_value` VARCHAR(45) PRIMARY KEY NOT NULL, "
" `value` INTEGER NOT NULL, "
"CREATE TABLE IF NOT EXISTS `version`( "
" `number` VARCHAR(45) NOT NULL "
"); "
- "INSERT OR IGNORE INTO `version` (`number`) VALUES('0'); "
"CREATE TABLE IF NOT EXISTS `rpc`( "
" `id` INTEGER PRIMARY KEY NOT NULL, "
" `name` VARCHAR(45) NOT NULL, "
" `is_default` BOOLEAN, "
" `is_predata` BOOLEAN, "
" `memory_kb` INTEGER NOT NULL, "
- " `watchdog_timer_ms` INTEGER NOT NULL, "
+ " `heart_beat_timeout_ms` INTEGER NOT NULL, "
" `certificate` VARCHAR(45), "
" CONSTRAINT `fk_application_hmi_level1` "
" FOREIGN KEY(`default_hmi`) "
" ON `message`(`message_type_name`);"
"COMMIT;";
+const std::string kInsertInitData =
+ "INSERT OR IGNORE INTO `usage_and_error_count` ( "
+ " `count_of_iap_buffer_full`, `count_sync_out_of_memory`, "
+ " `count_of_sync_reboots`) VALUES (0, 0, 0); "
+ "INSERT OR IGNORE INTO `module_meta` (`pt_exchanged_at_odometer_x`, "
+ " `pt_exchanged_x_days_after_epoch`, `ignition_cycles_since_last_exchange`,"
+ " `flag_update_required`) "
+ " VALUES (0, 0, 0, 0); "
+ "INSERT OR IGNORE INTO `module_config` (`preloaded_pt`, "
+ " `exchange_after_x_ignition_cycles`, `exchange_after_x_kilometers`, "
+ " `exchange_after_x_days`, `timeout_after_x_seconds`) "
+ " VALUES(1, 0, 0, 0, 0); "
+ "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('EMERGENCY'); "
+ "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NAVIGATION'); "
+ "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('VOICECOMMUNICATION'); "
+ "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('COMMUNICATION'); "
+ "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NORMAL'); "
+ "INSERT OR IGNORE INTO `priority`(`value`) VALUES ('NONE'); "
+ "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('FULL'); "
+ "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('LIMITED'); "
+ "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('BACKGROUND'); "
+ "INSERT OR IGNORE INTO `hmi_level`(`value`) VALUES ('NONE'); "
+ "INSERT OR IGNORE INTO `version` (`number`) VALUES('0'); "
+ "";
+
const std::string kDropSchema =
"BEGIN; "
"DROP INDEX IF EXISTS `message.fk_messages_languages1_idx`; "
"DROP TABLE IF EXISTS `module_meta`; "
"DROP TABLE IF EXISTS `usage_and_error_count`; "
"DROP TABLE IF EXISTS `device`; "
- "COMMIT;";
+ "COMMIT; "
+ "VACUUM;";
+
+const std::string kDeleteData =
+ "BEGIN; "
+ "DELETE FROM `message`; "
+ "DELETE FROM `endpoint`; "
+ "DELETE FROM `consent_group`; "
+ "DELETE FROM `app_type`; "
+ "DELETE FROM `nickname`; "
+ "DELETE FROM `app_level`; "
+ "DELETE FROM `device_consent_group`; "
+ "DELETE FROM `seconds_between_retry`; "
+ "DELETE FROM `preconsented_group`; "
+ "DELETE FROM `app_group`; "
+ "DELETE FROM `application`; "
+ "DELETE FROM `rpc`; "
+ "DELETE FROM `version`; "
+ "DELETE FROM `message_type`; "
+ "DELETE FROM `language`; "
+ "DELETE FROM `notifications_by_priority`; "
+ "DELETE FROM `hmi_level`; "
+ "DELETE FROM `priority`; "
+ "DELETE FROM `functional_group`; "
+ "DELETE FROM `module_config`; "
+ "DELETE FROM `module_meta`; "
+ "DELETE FROM `usage_and_error_count`; "
+ "DELETE FROM `device`; "
+ "COMMIT; "
+ "VACUUM;";
const std::string kCheckDBIntegrity = "PRAGMA integrity_check";
const std::string kInsertApplication =
"INSERT OR IGNORE INTO `application` (`id`, `is_revoked`, `memory_kb`,"
- " `watchdog_timer_ms`, `certificate`) VALUES (?,?,?,?,?)";
+ " `heart_beat_timeout_ms`, `certificate`) VALUES (?,?,?,?,?)";
const std::string kInsertAppGroup =
"INSERT INTO `app_group` (`application_id`, `functional_group_id`)"
"SELECT DISTINCT `number` FROM `version`";
const std::string kSelectAppPolicies = "SELECT `id`, `memory_kb`, "
- " `watchdog_timer_ms`, `certificate` FROM `application`";
+ " `heart_beat_timeout_ms`, `certificate` FROM `application`";
const std::string kSelectAppGroups = "SELECT `f`.`name` FROM `app_group` AS `a`"
" LEFT JOIN `functional_group` AS `f` "
}
dbms::SQLQuery query(db());
if (!query.Exec(sql_pt::kCreateSchema)) {
- LOG4CXX_INFO(
+ LOG4CXX_ERROR(
logger_,
"Failed creating schema of database: " << query.LastError().text());
return InitResult::FAIL;
}
+ if (!query.Exec(sql_pt::kInsertInitData)) {
+ LOG4CXX_ERROR(
+ logger_,
+ "Failed insert init data to database: " << query.LastError().text());
+ return InitResult::FAIL;
+ }
return InitResult::SUCCESS;
}
return VehicleData();
}
-bool SQLPTRepresentation::Clear() {
+bool SQLPTRepresentation::Drop() {
dbms::SQLQuery query(db());
if (!query.Exec(sql_pt::kDropSchema)) {
LOG4CXX_WARN(logger_,
+ "Failed dropping database: " << query.LastError().text());
+ return false;
+ }
+ return true;
+}
+
+bool SQLPTRepresentation::Clear() {
+ dbms::SQLQuery query(db());
+ if (!query.Exec(sql_pt::kDeleteData)) {
+ LOG4CXX_ERROR(logger_,
"Failed clearing database: " << query.LastError().text());
return false;
}
+ if (!query.Exec(sql_pt::kInsertInitData)) {
+ LOG4CXX_ERROR(
+ logger_,
+ "Failed insert init data to database: " << query.LastError().text());
+ return false;
+ }
return true;
}
GatherDeviceData(&*table->policy_table.device_data);
GatherFunctionalGroupings(&table->policy_table.functional_groupings);
GatherConsumerFriendlyMessages(
- &table->policy_table.consumer_friendly_messages);
+ &*table->policy_table.consumer_friendly_messages);
GatherApplicationPolicies(&table->policy_table.app_policies);
return table;
}
config->timeout_after_x_seconds = query.GetInteger(4);
*config->vehicle_make = query.GetString(5);
*config->vehicle_model = query.GetString(6);
- *config->vehicle_year = query.GetInteger(7);
+ *config->vehicle_year = query.GetString(7);
}
dbms::SQLQuery endpoints(db());
continue;
}
*params.memory_kb = query.GetInteger(1);
- *params.watchdog_timer_ms = query.GetInteger(2);
+ *params.heart_beat_timeout_ms = query.GetInteger(2);
if (!query.IsNull(3)) {
*params.certificate = query.GetString(3);
}
return false;
}
if (!SaveConsumerFriendlyMessages(
- table.policy_table.consumer_friendly_messages)) {
+ *table.policy_table.consumer_friendly_messages)) {
db_->RollbackTransaction();
return false;
}
app_query.Bind(0, it->first);
app_query.Bind(1, it->second.is_null());
app_query.Bind(2, it->second.memory_kb);
- app_query.Bind(3, it->second.watchdog_timer_ms);
+ app_query.Bind(3, it->second.heart_beat_timeout_ms);
it->second.certificate.is_initialized() ?
app_query.Bind(4, *it->second.certificate) : app_query.Bind(4);
}
LOG4CXX_INFO(logger_, "Saving data for application: " << it->first);
+ if (it->second.is_string()) {
+ if (kDefaultId.compare(it->second.get_string()) == 0) {
+ if (!SetDefaultPolicy(it->first)) {
+ return false;
+ }
+ }
+ continue;
+ }
+
if (!SaveAppGroup(it->first, it->second.groups)) {
return false;
}
return SetIsDefault(app_id, true);
}
-bool SQLPTRepresentation::CleanupUnpairedDevices(const DeviceIds& device_ids) {
- LOG4CXX_INFO(logger_, "CleanupUnpairedDevices");
- dbms::SQLQuery delete_device_query(db());
- if (!delete_device_query.Prepare(sql_pt::kDeleteDevice)) {
- LOG4CXX_WARN(logger_, "Incorrect statement for device delete.");
- return true;
- }
-
- DeviceIds::const_iterator it = device_ids.begin();
- DeviceIds::const_iterator it_end = device_ids.end();
- for (; it != it_end; ++it) {
- delete_device_query.Bind(0, (*it));
- if (!delete_device_query.Exec() || !delete_device_query.Reset()) {
- LOG4CXX_WARN(logger_, "Failed to delete from device");
- return false;
- }
- }
- return true;
-}
-
bool SQLPTRepresentation::SetIsDefault(const std::string& app_id,
- bool is_default) {
+ bool is_default) const {
LOG4CXX_TRACE(logger_, "Set flag is_default of application");
dbms::SQLQuery query(db());
if (!query.Prepare(sql_pt::kUpdateIsDefault)) {
+++ /dev/null
-/*
- Copyright (c) 2013, 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/syncp_adapter.h"
-
-namespace policy {
-SyncPAdapter::SyncPAdapter() {
-}
-
-SyncPAdapter::~SyncPAdapter() {
-}
-
-bool SyncPAdapter::ParseHeader(const PTString& input) {
- // TODO(PV): add implementation
- update_.msg_id = 10;
- return true;
-}
-
-bool SyncPAdapter::ComposeHeader() {
- // TODO(PV): add implementation
- snapshot_.msg_id = 9;
- return true;
-}
-
-PTString* SyncPAdapter::Decrypt(const PTString& input) {
- // TODO(PV): add implementation
- return new PTString("policy_table_string");
-}
-
-PTString* SyncPAdapter::Encrypt(const PTString& input) {
- // TODO(PV): add implementation
- return new PTString("policy_table_encrypted_string");
-}
-bool SyncPAdapter::ValidateUpdate() {
- return true;
-}
-
-} // namespace policy
${CMAKE_SOURCE_DIR}/src/thirdPartyLibs/gmock-1.7.0/gtest/include
${CMAKE_SOURCE_DIR}/src/thirdPartyLibs/jsoncpp/include/
${CMAKE_SOURCE_DIR}/src/components/policy/src/policy/include/
- ${CMAKE_BINARY_DIR}/src/components/policy/src/policy/
${CMAKE_SOURCE_DIR}/src/components/rpc_base/include
${CMAKE_SOURCE_DIR}/src/components/policy/src/policy/sqlite_wrapper/include
${CMAKE_SOURCE_DIR}/src/components/policy/src/policy/qdb_wrapper/include
create_test("test_generated_code_with_sqlite" "${GENERATED_CODE_WITH_SQLITE_SOURCES}" "${LIBRARIES}")
if (EXTENDED_POLICY_FLAG)
+ include_directories(${CMAKE_SOURCE_DIR}/src/components/policy/src/policy/policy_table/table_struct_ext)
set(SQL_PT_EXT_REPRESENTATION_SOURCES
./src/test_sql_pt_ext_representation.cc
)
create_test("test_SQLPTExtRepresentation" "${SQL_PT_EXT_REPRESENTATION_SOURCES}" "${LIBRARIES}")
else ()
+ include_directories(${CMAKE_SOURCE_DIR}/src/components/policy/src/policy/policy_table/table_struct)
# TODO(KKolodiy): test crashes in QNX and failed for extended policy
create_test("test_stress_PolicyManagerImpl" "${STRESS_POLICY_MANAGER_IMPL_SOURCES}" "${LIBRARIES}")
endif ()
#ifndef GENERATED_CODE_WITH_SQLITE_TEST_H_
#define GENERATED_CODE_WITH_SQLITE_TEST_H_
-#include "policy_table_interface_base/types.h"
+#include "./types.h"
#include "rpc_base/rpc_base.h"
#include "sqlite_wrapper/sql_query.h"
#include "sqlite_wrapper/sql_database.h"
#include "gmock/gmock.h"
#include "policy/policy_listener.h"
#include "rpc_base/rpc_base.h"
-#include "policy_table_interface_base/types.h"
+#include "./types.h"
namespace policy_table = ::rpc::policy_table_interface_base;
#include "gmock/gmock.h"
#include "policy/pt_ext_representation.h"
#include "rpc_base/rpc_base.h"
-#include "policy_table_interface_base/types.h"
+#include "./types.h"
#include "mock_pt_representation.h"
namespace policy_table = ::rpc::policy_table_interface_base;
bool(const std::string& app_id, std::string* priority));
MOCK_METHOD0(ResetUserConsent,
bool());
+ MOCK_METHOD0(ResetDeviceConsents, bool());
+ MOCK_METHOD0(ResetAppConsents, bool());
MOCK_METHOD3(GetUserPermissionsForDevice,
bool(const std::string&, StringArray*, StringArray*));
MOCK_METHOD3(GetUserPermissionsForApp,
void(const std::string& app_id, const std::string& type, const std::string& value));
MOCK_CONST_METHOD3(Add,
void(const std::string& app_id, const std::string& type, int seconds));
- MOCK_CONST_METHOD2(CountUnconsentedGroups,
- bool(const std::string& app_id, int* count));
+ MOCK_CONST_METHOD3(CountUnconsentedGroups,
+ bool(const std::string& app_id,
+ const std::string& device_id,
+ int* count));
MOCK_METHOD1(GetFunctionalGroupNames,
bool(FunctionalGroupNames& names));
- MOCK_METHOD1(CleanupUnpairedDevices,
- bool(const DeviceIds& device_ids));
+ MOCK_CONST_METHOD1(CleanupUnpairedDevices,
+ bool(const DeviceIds& device_ids));
MOCK_METHOD2(ReactOnUserDevConsentForApp,
bool(const std::string& app_id, bool is_device_allowed));
MOCK_METHOD1(SetPredataPolicy, bool(const std::string& app_id));
MOCK_METHOD2(SetIsPredata, bool(const std::string& app_id, bool is_predata));
+ MOCK_CONST_METHOD1(SetUnpairedDevice, bool(const std::string& device_id));
+ MOCK_CONST_METHOD1(UnpairedDevicesList, bool(DeviceIds* device_ids));
};
} // namespace policy
#include "gmock/gmock.h"
#include "policy/pt_representation.h"
#include "rpc_base/rpc_base.h"
-#include "policy_table_interface_base/types.h"
+#include "./types.h"
namespace policy_table = ::rpc::policy_table_interface_base;
bool());
MOCK_METHOD0(Clear,
bool());
+ MOCK_METHOD0(Drop,
+ bool());
MOCK_CONST_METHOD0(GenerateSnapshot,
utils::SharedPtr<policy_table::Table>());
MOCK_METHOD1(Save,
MOCK_CONST_METHOD1(IsApplicationRepresented, bool(const std::string& app_id));
MOCK_CONST_METHOD1(IsDefaultPolicy, bool(const std::string& app_id));
MOCK_METHOD1(SetDefaultPolicy, bool(const std::string& app_id));
- MOCK_METHOD1(CleanupUnpairedDevices,
- bool(const DeviceIds& device_ids));
MOCK_CONST_METHOD1(IsPredataPolicy, bool(const std::string& app_id));
};
gmock
gmock_main
dbms
+ sqlite3
)
set(DATABASE_SOURCES
)
create_test("test_SQLDatabase" "${DATABASE_SOURCES}" "${LIBRARIES}")
-create_test("test_SQLQuery" "${QUERY_SOURCES}" "${LIBRARIES}")
\ No newline at end of file
+create_test("test_SQLQuery" "${QUERY_SOURCES}" "${LIBRARIES}")
#include <gtest/gtest.h>
#include "json/reader.h"
#include "json/value.h"
-#include "policy_table_interface_base/enums.h"
-#include "policy_table_interface_base/types.h"
+#include "./enums.h"
+#include "./types.h"
#include "rpc_base/gtest_support.h"
using namespace rpc::policy_table_interface_base;
}
#endif // EXTENDED_POLICY
-TEST_F(PolicyManagerImplTest, LoadPTFromFile) {
+TEST_F(PolicyManagerImplTest, ResetPT) {
::testing::NiceMock<MockPTRepresentation> mock_pt;
EXPECT_CALL(mock_pt, Init()).WillOnce(Return(::policy::NONE))
PolicyManagerImpl* manager = new PolicyManagerImpl();
manager->ResetDefaultPT(::policy::PolicyTable(&mock_pt));
- EXPECT_FALSE(manager->LoadPTFromFile("filename"));
+ EXPECT_FALSE(manager->ResetPT("filename"));
// TODO(AOleynik): Sometimes fails, check this
- // EXPECT_TRUE(manager->LoadPTFromFile("filename"));
- // EXPECT_TRUE(manager->LoadPTFromFile("filename"));
- EXPECT_FALSE(manager->LoadPTFromFile("filename"));
+ // EXPECT_TRUE(manager->ResetPT("filename"));
+ // EXPECT_TRUE(manager->ResetPT("filename"));
+ EXPECT_FALSE(manager->ResetPT("filename"));
}
TEST_F(PolicyManagerImplTest, CheckPermissions) {
//manager->GetPolicyTableStatus();
}
+TEST_F(PolicyManagerImplTest, MarkUnpairedDevice) {
+ ::testing::NiceMock<MockPTExtRepresentation> mock_pt;
+
+ EXPECT_CALL(mock_pt, SetUnpairedDevice("12345")).WillOnce(Return(true));
+
+ PolicyManagerImpl* manager = new PolicyManagerImpl();
+ manager->ResetDefaultPT(::policy::PolicyTable(&mock_pt));
+ manager->MarkUnpairedDevice("12345");
+}
+
+
} // namespace policy
} // namespace components
} // namespace test
#include <gtest/gtest.h>
#include <sqlite3.h>
#include <vector>
+#include <algorithm>
#include "json/value.h"
#include "policy/sql_pt_ext_representation.h"
#include "policy/policy_types.h"
-#include "policy_table_interface_base/types.h"
-#include "policy_table_interface_base/enums.h"
+#include "./types.h"
+#include "./enums.h"
using policy::SQLPTExtRepresentation;
namespace policy {
class SQLPTExtRepresentationTest : public ::testing::Test {
- protected:
- static sqlite3* conn;
- static SQLPTExtRepresentation* reps;
- static const std::string kFileName;
-
- static void SetUpTestCase() {
- reps = new SQLPTExtRepresentation;
- EXPECT_EQ(::policy::SUCCESS, reps->Init());
- EXPECT_EQ(SQLITE_OK, sqlite3_open(kFileName.c_str(), &conn));
- }
-
- static void TearDownTestCase() {
- EXPECT_TRUE(reps->Clear());
- EXPECT_TRUE(reps->Close());
- delete reps;
- sqlite3_close(conn);
- remove(kFileName.c_str());
- }
+ protected:
+ static sqlite3* conn;
+ static SQLPTExtRepresentation* reps;
+ static const std::string kFileName;
+
+ static void SetUpTestCase() {
+ reps = new SQLPTExtRepresentation;
+ EXPECT_EQ(::policy::SUCCESS, reps->Init());
+ EXPECT_EQ(SQLITE_OK, sqlite3_open(kFileName.c_str(), &conn));
+ }
+
+ static void TearDownTestCase() {
+ EXPECT_TRUE(reps->Drop());
+ EXPECT_TRUE(reps->Close());
+ delete reps;
+ sqlite3_close(conn);
+ remove(kFileName.c_str());
+ }
};
sqlite3* SQLPTExtRepresentationTest::conn = 0;
SQLPTExtRepresentation* SQLPTExtRepresentationTest::reps = 0;
const std::string SQLPTExtRepresentationTest::kFileName = "policy.sqlite";
-::testing::AssertionResult IsValid(const policy_table::Table &table) {
+::testing::AssertionResult IsValid(const policy_table::Table& table) {
if (table.is_valid()) {
return ::testing::AssertionSuccess();
} else {
module_config["endpoints"]["0x00"] = Json::Value(Json::objectValue);
module_config["endpoints"]["0x00"]["default"] = Json::Value(Json::arrayValue);
module_config["endpoints"]["0x00"]["default"][0] = Json::Value(
- "http://ford.com/cloud/default");
+ "http://ford.com/cloud/default");
module_config["notifications_per_minute_by_priority"] = Json::Value(
- Json::objectValue);
+ Json::objectValue);
module_config["notifications_per_minute_by_priority"]["emergency"] =
- Json::Value(1);
+ Json::Value(1);
module_config["notifications_per_minute_by_priority"]["navigation"] =
- Json::Value(2);
+ Json::Value(2);
module_config["notifications_per_minute_by_priority"]["voiceCommunication"] =
- Json::Value(3);
+ Json::Value(3);
module_config["notifications_per_minute_by_priority"]["communication"] =
- Json::Value(4);
+ Json::Value(4);
module_config["notifications_per_minute_by_priority"]["normal"] = Json::Value(
- 5);
+ 5);
module_config["notifications_per_minute_by_priority"]["none"] = Json::Value(
- 6);
+ 6);
module_config["vehicle_make"] = Json::Value("MakeT");
module_config["vehicle_model"] = Json::Value("ModelT");
module_config["vehicle_year"] = Json::Value(2014);
default_group["rpcs"]["Update"]["parameters"][0] = Json::Value("speed");
Json::Value& consumer_friendly_messages =
- policy_table["consumer_friendly_messages"];
+ policy_table["consumer_friendly_messages"];
consumer_friendly_messages["version"] = Json::Value("1.2");
Json::Value& app_policies = policy_table["app_policies"];
const char* query_delete = "DELETE FROM `application`; ";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
const char* query_insert = "INSERT INTO `application` (`id`, `memory_kb`,"
- " `watchdog_timer_ms`, `keep_context`) VALUES ('12345', 5, 10, 1)";
+ " `watchdog_timer_ms`, `keep_context`) VALUES ('12345', 5, 10, 1)";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_insert, NULL, NULL, NULL));
EXPECT_FALSE(reps->CanAppKeepContext("0"));
EXPECT_TRUE(reps->CanAppKeepContext("12345"));
const char* query_delete = "DELETE FROM `application`; ";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
const char* query_insert = "INSERT INTO `application` (`id`, `memory_kb`,"
- " `watchdog_timer_ms`, `steal_focus`) VALUES ('12345', 5, 10, 1)";
+ " `watchdog_timer_ms`, `steal_focus`) VALUES ('12345', 5, 10, 1)";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_insert, NULL, NULL, NULL));
EXPECT_TRUE(reps->CanAppStealFocus("12345"));
EXPECT_FALSE(reps->CanAppStealFocus("0"));
TEST_F(SQLPTExtRepresentationTest, IncrementGlobalCounter) {
const char* query_update = "UPDATE `usage_and_error_count` SET"
- " `count_of_sync_reboots` = 0";
+ " `count_of_sync_reboots` = 0";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_update, NULL, NULL, NULL));
reps->Increment("count_of_sync_reboots");
reps->Increment("count_of_sync_reboots");
const char* query_select =
- "SELECT `count_of_sync_reboots` FROM `usage_and_error_count`";
+ "SELECT `count_of_sync_reboots` FROM `usage_and_error_count`";
sqlite3_stmt* statement;
ASSERT_EQ(SQLITE_OK,
sqlite3_prepare(conn, query_select, -1, &statement, NULL));
TEST_F(SQLPTExtRepresentationTest, IncrementAppCounter) {
const char* query_delete =
- "DELETE FROM `app_level` WHERE `application_id` = '12345'";
+ "DELETE FROM `app_level` WHERE `application_id` = '12345'";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
reps->Increment("12345", "count_of_user_selections");
reps->Increment("12345", "count_of_user_selections");
const char* query_select =
- "SELECT `count_of_user_selections` FROM `app_level`"
- " WHERE `application_id` = '12345'";
+ "SELECT `count_of_user_selections` FROM `app_level`"
+ " WHERE `application_id` = '12345'";
sqlite3_stmt* statement;
ASSERT_EQ(SQLITE_OK,
sqlite3_prepare(conn, query_select, -1, &statement, NULL));
TEST_F(SQLPTExtRepresentationTest, SetAppInfo) {
const char* query_delete =
- "DELETE FROM `app_level` WHERE `application_id` = '12345'";
+ "DELETE FROM `app_level` WHERE `application_id` = '12345'";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
reps->Set("12345", "app_registration_language_gui", "ru-ru");
reps->Set("12345", "app_registration_language_vui", "en-en");
const char* query_select = "SELECT `app_registration_language_gui`, "
- " `app_registration_language_vui` FROM `app_level`"
- " WHERE `application_id` = '12345'";
+ " `app_registration_language_vui` FROM `app_level`"
+ " WHERE `application_id` = '12345'";
sqlite3_stmt* statement;
ASSERT_EQ(SQLITE_OK,
sqlite3_prepare(conn, query_select, -1, &statement, NULL));
TEST_F(SQLPTExtRepresentationTest, AddAppStopwatch) {
const char* query_delete =
- "DELETE FROM `app_level` WHERE `application_id` = '12345'";
+ "DELETE FROM `app_level` WHERE `application_id` = '12345'";
ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
reps->Add("12345", "minutes_in_hmi_full", 10);
reps->Add("12345", "minutes_in_hmi_full", 60);
const char* query_select = "SELECT `minutes_in_hmi_full` FROM `app_level`"
- " WHERE `application_id` = '12345'";
+ " WHERE `application_id` = '12345'";
sqlite3_stmt* statement;
ASSERT_EQ(SQLITE_OK,
sqlite3_prepare(conn, query_select, -1, &statement, NULL));
EXPECT_EQ(SQLITE_DONE, sqlite3_step(statement));
}
+TEST_F(SQLPTExtRepresentationTest, SetUnpairedDevice) {
+ const char* query_delete = "DELETE FROM `device`";
+ ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
+ const char* query_insert = "INSERT INTO `device` (`id`) VALUES('12345')";
+ ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_insert, NULL, NULL, NULL));
+
+ ASSERT_TRUE(reps->SetUnpairedDevice("12345"));
+
+ const char* query_select = "SELECT `id` FROM `device` WHERE `unpaired` = 1";
+ sqlite3_stmt* statement;
+ ASSERT_EQ(SQLITE_OK,
+ sqlite3_prepare(conn, query_select, -1, &statement, NULL));
+ ASSERT_EQ(SQLITE_ROW, sqlite3_step(statement));
+ std::string output(reinterpret_cast<const char*>(sqlite3_column_text(statement, 0)));
+ EXPECT_EQ("12345", output);
+ EXPECT_EQ(SQLITE_DONE, sqlite3_step(statement));
+}
+
+TEST_F(SQLPTExtRepresentationTest, UnpairedDevicesList) {
+ const char* query_delete = "DELETE FROM `device`";
+ ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_delete, NULL, NULL, NULL));
+ const char* query_insert = "INSERT INTO `device` (`id`, `unpaired`)"
+ " VALUES('12345', 1)";
+ ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_insert, NULL, NULL, NULL));
+ query_insert = "INSERT INTO `device` (`id`, `unpaired`) VALUES('54321', 1)";
+ ASSERT_EQ(SQLITE_OK, sqlite3_exec(conn, query_insert, NULL, NULL, NULL));
+
+ std::vector<std::string> output;
+ ASSERT_TRUE(reps->UnpairedDevicesList(&output));
+ ASSERT_EQ(2, output.size());
+ EXPECT_NE(output.end(), std::find(output.begin(), output.end(), "12345"));
+ EXPECT_NE(output.end(), std::find(output.begin(), output.end(), "54321"));
+}
+
} // namespace policy
} // namespace components
} // namespace test
#include "json/value.h"
#include "policy/sql_pt_representation.h"
#include "policy/policy_types.h"
-#include "policy_table_interface_base/types.h"
-#include "policy_table_interface_base/enums.h"
+#include "./types.h"
+#include "./enums.h"
using policy::SQLPTRepresentation;
using policy::CheckPermissionResult;
#ifdef __QNX__
class DBMS {
- public:
- bool Open() {
- conn_ = qdb_connect(kDatabaseName_.c_str(), 0);
- return conn_ != NULL;
- }
- void Close() {
- qdb_disconnect(conn_);
- }
- bool Exec(const char* query) {
- return -1 != qdb_statement(conn_, query);
- }
- private:
- static qdb_hdl_t* conn_;
- static const std::string kDatabaseName_;
+ public:
+ bool Open() {
+ conn_ = qdb_connect(kDatabaseName_.c_str(), 0);
+ return conn_ != NULL;
+ }
+ void Close() {
+ qdb_disconnect(conn_);
+ }
+ bool Exec(const char* query) {
+ return -1 != qdb_statement(conn_, query);
+ }
+ private:
+ static qdb_hdl_t* conn_;
+ static const std::string kDatabaseName_;
};
qdb_hdl_t* DBMS::conn_ = 0;
const std::string DBMS::kDatabaseName_ = "policy";
#else // __QNX__
class DBMS {
- public:
- bool Open() {
- return SQLITE_OK == sqlite3_open(kFileName_.c_str(), &conn_);
- }
- void Close() {
- sqlite3_close(conn_);
- remove(kFileName_.c_str());
- }
- bool Exec(const char* query) {
- return SQLITE_OK == sqlite3_exec(conn_, query, NULL, NULL, NULL);
- }
- private:
- static sqlite3* conn_;
- static const std::string kFileName_;
+ public:
+ bool Open() {
+ return SQLITE_OK == sqlite3_open(kFileName_.c_str(), &conn_);
+ }
+ void Close() {
+ sqlite3_close(conn_);
+ remove(kFileName_.c_str());
+ }
+ bool Exec(const char* query) {
+ return SQLITE_OK == sqlite3_exec(conn_, query, NULL, NULL, NULL);
+ }
+ private:
+ static sqlite3* conn_;
+ static const std::string kFileName_;
};
sqlite3* DBMS::conn_ = 0;
const std::string DBMS::kFileName_ = "policy.sqlite";
#endif // __QNX__
class SQLPTRepresentationTest : public ::testing::Test {
- protected:
- static DBMS* dbms;
- static SQLPTRepresentation* reps;
-
- static void SetUpTestCase() {
- reps = new SQLPTRepresentation;
- dbms = new DBMS;
- EXPECT_EQ(::policy::SUCCESS, reps->Init());
- EXPECT_TRUE(dbms->Open());
- }
-
- static void TearDownTestCase() {
- EXPECT_TRUE(reps->Clear());
- EXPECT_TRUE(reps->Close());
- delete reps;
- dbms->Close();
- }
+ protected:
+ static DBMS* dbms;
+ static SQLPTRepresentation* reps;
+
+ static void SetUpTestCase() {
+ reps = new SQLPTRepresentation;
+ dbms = new DBMS;
+ EXPECT_EQ(::policy::SUCCESS, reps->Init());
+ EXPECT_TRUE(dbms->Open());
+ }
+
+ static void TearDownTestCase() {
+ EXPECT_TRUE(reps->Drop());
+ EXPECT_TRUE(reps->Close());
+ delete reps;
+ dbms->Close();
+ }
};
DBMS* SQLPTRepresentationTest::dbms = 0;
SQLPTRepresentation* SQLPTRepresentationTest::reps = 0;
-::testing::AssertionResult IsValid(const policy_table::Table &table) {
+::testing::AssertionResult IsValid(const policy_table::Table& table) {
if (table.is_valid()) {
return ::testing::AssertionSuccess();
} else {
TEST_F(SQLPTRepresentationTest, CheckPermissionsAllowed) {
const char* query = "INSERT OR REPLACE INTO `application` (`id`, `memory_kb`,"
- " `watchdog_timer_ms`) VALUES ('12345', 5, 10); "
- "INSERT OR REPLACE INTO functional_group (`id`, `name`)"
- " VALUES (1, 'Base-4'); "
- "INSERT OR REPLACE INTO `app_group` (`application_id`,"
- " `functional_group_id`) VALUES ('12345', 1); "
- "INSERT OR REPLACE INTO `rpc` (`name`, `parameter`, `hmi_level_value`,"
- " `functional_group_id`) VALUES ('Update', 'gps', 'FULL', 1); "
- "INSERT OR REPLACE INTO `rpc` (`name`, `parameter`, `hmi_level_value`,"
- " `functional_group_id`) VALUES ('Update', 'speed', 'FULL', 1);";
+ " `watchdog_timer_ms`) VALUES ('12345', 5, 10); "
+ "INSERT OR REPLACE INTO functional_group (`id`, `name`)"
+ " VALUES (1, 'Base-4'); "
+ "INSERT OR REPLACE INTO `app_group` (`application_id`,"
+ " `functional_group_id`) VALUES ('12345', 1); "
+ "INSERT OR REPLACE INTO `rpc` (`name`, `parameter`, `hmi_level_value`,"
+ " `functional_group_id`) VALUES ('Update', 'gps', 'FULL', 1); "
+ "INSERT OR REPLACE INTO `rpc` (`name`, `parameter`, `hmi_level_value`,"
+ " `functional_group_id`) VALUES ('Update', 'speed', 'FULL', 1);";
ASSERT_TRUE(dbms->Exec(query));
CheckPermissionResult ret;
TEST_F(SQLPTRepresentationTest, CheckPermissionsAllowedWithoutParameters) {
const char* query = "INSERT OR REPLACE INTO `application` (`id`, `memory_kb`,"
- " `watchdog_timer_ms`) VALUES ('12345', 5, 10); "
- "INSERT OR REPLACE INTO functional_group (`id`, `name`)"
- " VALUES (1, 'Base-4'); "
- "INSERT OR REPLACE INTO `app_group` (`application_id`,"
- " `functional_group_id`) VALUES ('12345', 1); "
- "DELETE FROM `rpc`; "
- "INSERT OR REPLACE INTO `rpc` (`name`, `hmi_level_value`,"
- " `functional_group_id`) VALUES ('Update', 'LIMITED', 1);";
+ " `watchdog_timer_ms`) VALUES ('12345', 5, 10); "
+ "INSERT OR REPLACE INTO functional_group (`id`, `name`)"
+ " VALUES (1, 'Base-4'); "
+ "INSERT OR REPLACE INTO `app_group` (`application_id`,"
+ " `functional_group_id`) VALUES ('12345', 1); "
+ "DELETE FROM `rpc`; "
+ "INSERT OR REPLACE INTO `rpc` (`name`, `hmi_level_value`,"
+ " `functional_group_id`) VALUES ('Update', 'LIMITED', 1);";
ASSERT_TRUE(dbms->Exec(query));
CheckPermissionResult ret;
EXPECT_TRUE(ret.empty());
const char* query_insert =
- "INSERT INTO `endpoint` (`application_id`, `url`, `service`) "
- " VALUES ('12345', 'http://ford.com/cloud/1', '0x07');"
- "INSERT INTO `endpoint` (`application_id`, `url`, `service`) "
- " VALUES ('12345', 'http://ford.com/cloud/2', '0x07');";
+ "INSERT INTO `endpoint` (`application_id`, `url`, `service`) "
+ " VALUES ('12345', 'http://ford.com/cloud/1', '0x07');"
+ "INSERT INTO `endpoint` (`application_id`, `url`, `service`) "
+ " VALUES ('12345', 'http://ford.com/cloud/2', '0x07');";
ASSERT_TRUE(dbms->Exec(query_insert));
ret = reps->GetUpdateUrls(7);
TEST_F(SQLPTRepresentationTest, IgnitionCyclesBeforeExchangeAndIncrement) {
const char* query_zeros = "UPDATE `module_meta` SET "
- " `ignition_cycles_since_last_exchange` = 0; "
- " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 0";
+ " `ignition_cycles_since_last_exchange` = 0; "
+ " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 0";
ASSERT_TRUE(dbms->Exec(query_zeros));
EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange());
reps->IncrementIgnitionCycles();
EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange());
const char* query_less_limit = "UPDATE `module_meta` SET "
- " `ignition_cycles_since_last_exchange` = 5; "
- " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10";
+ " `ignition_cycles_since_last_exchange` = 5; "
+ " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10";
ASSERT_TRUE(dbms->Exec(query_less_limit));
EXPECT_EQ(5, reps->IgnitionCyclesBeforeExchange());
reps->IncrementIgnitionCycles();
EXPECT_EQ(4, reps->IgnitionCyclesBeforeExchange());
const char* query_limit = "UPDATE `module_meta` SET "
- " `ignition_cycles_since_last_exchange` = 9; "
- " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10";
+ " `ignition_cycles_since_last_exchange` = 9; "
+ " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10";
ASSERT_TRUE(dbms->Exec(query_limit));
EXPECT_EQ(1, reps->IgnitionCyclesBeforeExchange());
reps->IncrementIgnitionCycles();
EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange());
const char* query_more_limit = "UPDATE `module_meta` SET "
- " `ignition_cycles_since_last_exchange` = 12; "
- " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10";
+ " `ignition_cycles_since_last_exchange` = 12; "
+ " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 10";
ASSERT_TRUE(dbms->Exec(query_more_limit));
EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange());
const char* query_negative_limit = "UPDATE `module_meta` SET "
- " `ignition_cycles_since_last_exchange` = 3; "
- " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = -1";
+ " `ignition_cycles_since_last_exchange` = 3; "
+ " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = -1";
ASSERT_TRUE(dbms->Exec(query_negative_limit));
EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange());
const char* query_negative_current = "UPDATE `module_meta` SET "
- " `ignition_cycles_since_last_exchange` = -1; "
- " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 2";
+ " `ignition_cycles_since_last_exchange` = -1; "
+ " UPDATE `module_config` SET `exchange_after_x_ignition_cycles` = 2";
ASSERT_TRUE(dbms->Exec(query_negative_current));
EXPECT_EQ(0, reps->IgnitionCyclesBeforeExchange());
}
TEST_F(SQLPTRepresentationTest, KilometersBeforeExchange) {
const char* query_zeros = "UPDATE `module_meta` SET "
- " `pt_exchanged_at_odometer_x` = 0; "
- " UPDATE `module_config` SET `exchange_after_x_kilometers` = 0";
+ " `pt_exchanged_at_odometer_x` = 0; "
+ " UPDATE `module_config` SET `exchange_after_x_kilometers` = 0";
ASSERT_TRUE(dbms->Exec(query_zeros));
EXPECT_EQ(0, reps->KilometersBeforeExchange(0));
EXPECT_EQ(0, reps->KilometersBeforeExchange(-10));
EXPECT_EQ(0, reps->KilometersBeforeExchange(10));
const char* query_negative_limit = "UPDATE `module_meta` SET "
- " `pt_exchanged_at_odometer_x` = 10; "
- " UPDATE `module_config` SET `exchange_after_x_kilometers` = -10";
+ " `pt_exchanged_at_odometer_x` = 10; "
+ " UPDATE `module_config` SET `exchange_after_x_kilometers` = -10";
ASSERT_TRUE(dbms->Exec(query_negative_limit));
EXPECT_EQ(0, reps->KilometersBeforeExchange(0));
EXPECT_EQ(0, reps->KilometersBeforeExchange(10));
const char* query_negative_last = "UPDATE `module_meta` SET "
- " `pt_exchanged_at_odometer_x` = -10; "
- " UPDATE `module_config` SET `exchange_after_x_kilometers` = 20";
+ " `pt_exchanged_at_odometer_x` = -10; "
+ " UPDATE `module_config` SET `exchange_after_x_kilometers` = 20";
ASSERT_TRUE(dbms->Exec(query_negative_last));
EXPECT_EQ(0, reps->KilometersBeforeExchange(0));
EXPECT_EQ(0, reps->KilometersBeforeExchange(10));
const char* query_limit = "UPDATE `module_meta` SET "
- " `pt_exchanged_at_odometer_x` = 10; "
- " UPDATE `module_config` SET `exchange_after_x_kilometers` = 100";
+ " `pt_exchanged_at_odometer_x` = 10; "
+ " UPDATE `module_config` SET `exchange_after_x_kilometers` = 100";
ASSERT_TRUE(dbms->Exec(query_limit));
EXPECT_EQ(0, reps->KilometersBeforeExchange(120));
EXPECT_EQ(60, reps->KilometersBeforeExchange(50));
TEST_F(SQLPTRepresentationTest, DaysBeforeExchange) {
const char* query_zeros = "UPDATE `module_meta` SET "
- " `pt_exchanged_x_days_after_epoch` = 0; "
- " UPDATE `module_config` SET `exchange_after_x_days` = 0";
+ " `pt_exchanged_x_days_after_epoch` = 0; "
+ " UPDATE `module_config` SET `exchange_after_x_days` = 0";
ASSERT_TRUE(dbms->Exec(query_zeros));
EXPECT_EQ(0, reps->DaysBeforeExchange(0));
EXPECT_EQ(0, reps->DaysBeforeExchange(-10));
EXPECT_EQ(0, reps->DaysBeforeExchange(10));
const char* query_negative_limit = "UPDATE `module_meta` SET "
- " `pt_exchanged_x_days_after_epoch` = 10; "
- " UPDATE `module_config` SET `exchange_after_x_days` = -10";
+ " `pt_exchanged_x_days_after_epoch` = 10; "
+ " UPDATE `module_config` SET `exchange_after_x_days` = -10";
ASSERT_TRUE(dbms->Exec(query_negative_limit));
EXPECT_EQ(0, reps->DaysBeforeExchange(0));
EXPECT_EQ(0, reps->DaysBeforeExchange(10));
const char* query_negative_last = "UPDATE `module_meta` SET "
- " `pt_exchanged_x_days_after_epoch` = -10; "
- " UPDATE `module_config` SET `exchange_after_x_days` = 20";
+ " `pt_exchanged_x_days_after_epoch` = -10; "
+ " UPDATE `module_config` SET `exchange_after_x_days` = 20";
ASSERT_TRUE(dbms->Exec(query_negative_last));
EXPECT_EQ(0, reps->DaysBeforeExchange(0));
EXPECT_EQ(0, reps->DaysBeforeExchange(10));
const char* query_limit = "UPDATE `module_meta` SET "
- " `pt_exchanged_x_days_after_epoch` = 10; "
- " UPDATE `module_config` SET `exchange_after_x_days` = 100";
+ " `pt_exchanged_x_days_after_epoch` = 10; "
+ " UPDATE `module_config` SET `exchange_after_x_days` = 100";
ASSERT_TRUE(dbms->Exec(query_limit));
EXPECT_EQ(0, reps->DaysBeforeExchange(120));
EXPECT_EQ(60, reps->DaysBeforeExchange(50));
EXPECT_EQ(0, seconds.size());
const char* query_insert =
- "INSERT INTO `seconds_between_retry` (`index`, `value`) "
- " VALUES (0, 10); "
- "INSERT INTO `seconds_between_retry` (`index`, `value`) "
- " VALUES (1, 20); ";
+ "INSERT INTO `seconds_between_retry` (`index`, `value`) "
+ " VALUES (0, 10); "
+ "INSERT INTO `seconds_between_retry` (`index`, `value`) "
+ " VALUES (1, 20); ";
ASSERT_TRUE(dbms->Exec(query_insert));
ASSERT_TRUE(reps->SecondsBetweenRetries(&seconds));
ASSERT_EQ(2, seconds.size());
TEST_F(SQLPTRepresentationTest, TimeoutResponse) {
const char* query =
- "UPDATE `module_config` SET `timeout_after_x_seconds` = 60";
+ "UPDATE `module_config` SET `timeout_after_x_seconds` = 60";
ASSERT_TRUE(dbms->Exec(query));
EXPECT_EQ(60, reps->TimeoutResponse());
}
module_config["endpoints"]["0x00"] = Json::Value(Json::objectValue);
module_config["endpoints"]["0x00"]["default"] = Json::Value(Json::arrayValue);
module_config["endpoints"]["0x00"]["default"][0] = Json::Value(
- "http://ford.com/cloud/default");
+ "http://ford.com/cloud/default");
module_config["notifications_per_minute_by_priority"] = Json::Value(
- Json::objectValue);
+ Json::objectValue);
module_config["notifications_per_minute_by_priority"]["emergency"] =
- Json::Value(1);
+ Json::Value(1);
module_config["notifications_per_minute_by_priority"]["navigation"] =
- Json::Value(2);
+ Json::Value(2);
module_config["notifications_per_minute_by_priority"]["voiceCommunication"] =
- Json::Value(3);
+ Json::Value(3);
module_config["notifications_per_minute_by_priority"]["communication"] =
- Json::Value(4);
+ Json::Value(4);
module_config["notifications_per_minute_by_priority"]["normal"] = Json::Value(
- 5);
+ 5);
module_config["notifications_per_minute_by_priority"]["none"] = Json::Value(
- 6);
+ 6);
module_config["vehicle_make"] = Json::Value("MakeT");
module_config["vehicle_model"] = Json::Value("ModelT");
module_config["vehicle_year"] = Json::Value(2014);
default_group["rpcs"]["Update"]["parameters"][0] = Json::Value("speed");
Json::Value& consumer_friendly_messages =
- policy_table["consumer_friendly_messages"];
+ policy_table["consumer_friendly_messages"];
consumer_friendly_messages["version"] = Json::Value("1.2");
Json::Value& app12345counters = usage_and_error_counts["app_level"]["12345"];
ofs.close();
manager = new PolicyManagerImpl();
- ASSERT_TRUE(manager->LoadPTFromFile(kNameFile));
+ ASSERT_TRUE(manager->InitPT(kNameFile));
}
static void TearDownTestCase() {
projects / profile / ivi / smartdevicelink.git / commitdiff