diff options
Diffstat (limited to 'src/components/policy/include/policy/policy_manager.h')
-rw-r--r-- | src/components/policy/include/policy/policy_manager.h | 481 |
1 files changed, 481 insertions, 0 deletions
diff --git a/src/components/policy/include/policy/policy_manager.h b/src/components/policy/include/policy/policy_manager.h new file mode 100644 index 0000000000..70ec5d23a2 --- /dev/null +++ b/src/components/policy/include/policy/policy_manager.h @@ -0,0 +1,481 @@ +/* + Copyright (c) 2016, Ford Motor Company + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the + distribution. + + Neither the name of the Ford Motor Company nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_MANAGER_H_ +#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_MANAGER_H_ + +#include <vector> +#include <cstdint> + +#include "policy/policy_types.h" +#include "policy/policy_listener.h" +#include "policy/usage_statistics/statistics_manager.h" + +namespace policy { +class PolicySettings; + +class PolicyManager : public usage_statistics::StatisticsManager { + public: + virtual ~PolicyManager() {} + + virtual void set_listener(PolicyListener* listener) = 0; + + /** + * Inits Policy Table + * @param file_name Path to preloaded PT file + * @return true if successfully + */ + virtual bool InitPT(const std::string& file_name, + const PolicySettings* settings) = 0; + + /** + * @brief Updates Policy Table from binary message received from + * mobile device. Saves to Policy Table diff between Policy Table + * sent in snapshot and received Policy Table. + * @param file name of file with update policy table + * @param pt_content PTU as binary string + * @return bool Success of operation + */ + 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 GetLockScreenIcon allows to obtain lock screen icon url; + * + * @return url which point to the resourse where lock screen icon could be + *obtained. + */ + virtual std::string GetLockScreenIconUrl() const = 0; + + /** + * @brief Gets all URLs for sending PTS to from PT itself. + * @param service_type Service specifies user of URL + * @return vector of urls + */ + virtual void GetServiceUrls(const std::string& service_type, + EndpointUrls& end_points) = 0; + + /** + * @brief PTU is needed, for this PTS has to be formed and sent. + */ + virtual bool RequestPTUpdate() = 0; + + /** + * @brief Check if specified RPC for specified application + * has permission to be executed in specified HMI Level + * and also its permitted params. + * @param app_id Id of application provided during registration + * @param hmi_level Current HMI Level of application + * @param rpc Name of RPC + * @param CheckPermissionResult containing flag if HMI Level is allowed + * and list of allowed params. + */ + virtual void CheckPermissions(const PTString& app_id, + const PTString& hmi_level, + const PTString& rpc, + const RPCParams& rpc_params, + CheckPermissionResult& result) = 0; + + /** + * @brief Clear all record of user consents. Used during Factory Reset. + * @return bool Success of operation + */ + virtual bool ResetUserConsent() = 0; + + /** + * @brief Returns current status of policy table for HMI + * @return Current status of policy table + */ + virtual std::string GetPolicyTableStatus() const = 0; + + /** + * Checks is PT exceeded kilometers + * @param kilometers current kilometers at odometer + * @return true if exceeded + */ + virtual void KmsChanged(int kilometers) = 0; + + /** + * Increments counter of ignition cycles + */ + virtual void IncrementIgnitionCycles() = 0; + + /** + * @brief ExchangeByUserRequest + */ + virtual std::string ForcePTExchange() = 0; + + /** + * Resets retry sequence + */ + virtual void ResetRetrySequence() = 0; + + /** + * Gets timeout to wait before next retry updating PT + * If timeout is equal to zero then the retry sequence is not need. + * @return timeout in seconds + */ + virtual uint32_t NextRetryTimeout() = 0; + + /** + * Gets timeout to wait until receive response + * @return timeout in seconds + */ + virtual int TimeoutExchange() = 0; + + /** + * @brief List of timeouts in seconds between retries + * when attempt to update PT fails + * @return List of delays between attempts. + */ + virtual const std::vector<int> RetrySequenceDelaysSeconds() = 0; + + /** + * Handler of exceeding timeout of exchanging policy table + */ + virtual void OnExceededTimeout() = 0; + + /** + * @brief Handler of PTS sending out + */ + virtual void OnUpdateStarted() = 0; + + /** + * @brief Check user consent for mobile device data connection + * @param device_id Unique device identifier + * @return status of device consent + */ + virtual DeviceConsent GetUserConsentForDevice( + const std::string& device_id) const = 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 + */ + virtual void SetUserConsentForDevice(const std::string& device_id, + bool is_allowed) = 0; + + /** + * @brief Update Application Policies as reaction + * on User allowing/disallowing device this app is running on. + */ + virtual bool ReactOnUserDevConsentForApp(const std::string app_id, + bool is_device_allowed) = 0; + /** + * Sets counter value that passed for receiving PT UPdate. + */ + virtual void PTUpdatedAt(Counters counter, int value) = 0; + + /** + * @brief Retrieves data from app_policies about app on its registration: + * @param app_id - id of registered app + * @param app_types Section on HMI where app can appear (Navigation, Phone + * etc) + * @param nicknames Synonyms for application + */ + virtual bool GetInitialAppData(const std::string& application_id, + StringArray* nicknames = NULL, + StringArray* app_hmi_types = NULL) = 0; + + /** + * @brief Add's device to policy table + * @param device_id Device mac address + * @param connection_type Device connection type + */ + virtual void AddDevice(const std::string& device_id, + const std::string& connection_type) = 0; + + /** + * @brief Stores device parameters received during application registration + * to policy table + * @param device_id Device mac address + * @param device_info Received device parameters + */ + virtual void SetDeviceInfo(const std::string& device_id, + const DeviceInfo& device_info) = 0; + + /** + * @brief Set user consent for application functional groups + * @param permissions User-defined application group pemissions. + * The permissions is not const reference because it may contains + * valid data as well as invalid. So we will remove all invalid data + * from this structure. + */ + virtual void SetUserConsentForApp(const PermissionConsent& permissions) = 0; + + /** + * @brief Get default HMI level for application + * @param policy_app_id Unique application id + * @param default_hmi Default HMI level for application or empty, if value + * was not set + * @return true, if succedeed, otherwise - false + */ + virtual bool GetDefaultHmi(const std::string& policy_app_id, + std::string* default_hmi) const = 0; + + /** + * @brief Get priority for application + * @param policy_app_id Unique application id + * @param priority Priority for application or empty, if value was not set + * @return true, if succedeed, otherwise - false + */ + virtual bool GetPriority(const std::string& policy_app_id, + std::string* priority) const = 0; + + /** + * @brief Get user friendly messages for given RPC messages and language + * @param message_codes RPC message codes + * @param language Language + * @return Array of structs with appropriate message parameters + */ + virtual std::vector<UserFriendlyMessage> GetUserFriendlyMessages( + const std::vector<std::string>& message_code, + const std::string& language) = 0; + + /** + * Checks if the application is revoked + * @param app_id application id + * @return true if application is revoked + */ + virtual bool IsApplicationRevoked(const std::string& app_id) const = 0; + + /** + * @brief Get resulting RPCs permissions for application which started on + * specific device + * @param device_id Device id + * @param policy_app_id Unique application id + * @param permissions Array of functional groups permissions + */ + virtual void GetPermissionsForApp( + const std::string& device_id, + const std::string& policy_app_id, + std::vector<FunctionalGroupPermission>& permissions) = 0; + + /** + * @brief Gets specific application permissions changes since last policy + * table update + * @param policy_app_id Unique application id + * @return Permissions changes + */ + virtual AppPermissions GetAppPermissionsChanges( + const std::string& policy_app_id) = 0; + + virtual void RemovePendingPermissionChanges(const std::string& app_id) = 0; + + /** + * @brief Return device id, which hosts specific application + * @param Application id, which is required to update device id + */ + virtual std::string& GetCurrentDeviceId( + const std::string& policy_app_id) const = 0; + + /** + * @brief Set current system language + * @param language Language + */ + virtual void SetSystemLanguage(const std::string& language) = 0; + + /** + * @brief Set data from GetSystemInfo response to policy table + * @param ccpu_version CCPU version + * @param wers_country_code WERS country code + * @param language System language + */ + virtual void SetSystemInfo(const std::string& ccpu_version, + const std::string& wers_country_code, + const std::string& language) = 0; + + /** + * @brief Send OnPermissionsUpdated for choosen application + * @param application_id + */ + virtual void SendNotificationOnPermissionsUpdated( + 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 Adds, application to the db or update existed one + * run PTU if policy update is necessary for application. + * @param Application id assigned by Ford to the application + */ + virtual void AddApplication(const std::string& application_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() = 0; + + /** + * @brief Check if app can keep context. + */ + virtual bool CanAppKeepContext(const std::string& app_id) const = 0; + + /** + * @brief Check if app can steal focus. + */ + virtual bool CanAppStealFocus(const std::string& app_id) const = 0; + + /** + * @brief Runs necessary operations, which is depends on external system + * state, e.g. getting system-specific parameters which are need to be + * filled into policy table + */ + virtual void OnSystemReady() = 0; + + /** + * @brief GetNotificationNumber + * @param priority + * @return + */ + virtual uint32_t GetNotificationsNumber( + const std::string& priority) const = 0; + + /** + * @brief Allows to update Vehicle Identification Number in policy table. + * @param new value for the parameter. + */ + virtual void SetVINValue(const std::string& value) = 0; + + /** + * @brief Checks, if application has policy assigned w/o data consent + * @param policy_app_id Unique application id + * @return true, if policy assigned w/o data consent, otherwise -false + */ + virtual bool IsPredataPolicy(const std::string& policy_app_id) = 0; + + /** + * Returns heart beat timeout + * @param app_id application id + * @return if timeout was set then value in milliseconds greater zero + * otherwise heart beat for specific application isn't set + */ + virtual uint32_t HeartBeatTimeout(const std::string& app_id) const = 0; + + /** + * @brief SaveUpdateStatusRequired alows to save update status. + */ + virtual void SaveUpdateStatusRequired(bool is_update_needed) = 0; + + /** + * @brief Handler on applications search started + */ + virtual void OnAppsSearchStarted() = 0; + + /** + * @brief Handler on applications search completed + */ + virtual void OnAppsSearchCompleted() = 0; + /** + * @brief Gets request types for application + * @param policy_app_id Unique application id + * @return request_types Request types of application + */ + virtual const std::vector<std::string> GetAppRequestTypes( + const std::string policy_app_id) const = 0; + + /** + * @brief Get information about vehicle + */ + virtual const VehicleInfo GetVehicleInfo() const = 0; + + /** + * @brief OnAppRegisteredOnMobile alows to handle event when application were + * succesfully registered on mobile device. + * It will send OnAppPermissionSend notification and will try to start PTU. + * + * @param application_id registered application. + */ + virtual void OnAppRegisteredOnMobile(const std::string& application_id) = 0; + + /** + * @brief RetrieveCertificate Allows to obtain certificate in order + * to start secure connection. + * + * @return The certificate in PKCS#7 format. + */ + virtual std::string RetrieveCertificate() const = 0; + + virtual const PolicySettings& get_settings() const = 0; + + protected: + /** + * Checks is PT exceeded IgnitionCycles + * @return true if exceeded + */ + virtual bool ExceededIgnitionCycles() = 0; + + /** + * Checks is PT exceeded days + * @return true if exceeded + */ + virtual bool ExceededDays() = 0; + + /** + * @brief StartPTExchange allows to start PTU. The function will check + * if one is required and starts the update flow in only case when previous + * condition is true. + */ + virtual void StartPTExchange() = 0; +}; + +} // namespace policy + +extern "C" policy::PolicyManager* CreateManager(); +extern "C" void DeleteManager(policy::PolicyManager*); + +#endif // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_MANAGER_H_ |