diff options
Diffstat (limited to 'src/components/application_manager/include/application_manager/policies')
16 files changed, 873 insertions, 513 deletions
diff --git a/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h b/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h index 6913f5038e..d836600ae3 100644 --- a/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h +++ b/src/components/application_manager/include/application_manager/policies/delegates/app_permission_delegate.h @@ -1,82 +1,5 @@ -/* - Copyright (c) 2014, 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_APP_PERMISSION_DELEGATE_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_APP_PERMISSION_DELEGATE_H_ - -#include "utils/threads/thread.h" -#include "utils/threads/thread_delegate.h" -#include "utils/conditional_variable.h" - -#include "policy/policy_types.h" -#include "application_manager/policies/policy_handler_interface.h" - -namespace policy { -/** -*@brief The AppPermissionDelegate class allows to call OnAppPermissionConsent -*in async way. -*/ -class AppPermissionDelegate : public threads::ThreadDelegate { - public: - /** - * @brief AppPermissionDelegate constructor, contains parameters - * which will be pass to the called function. - * - * @param connection_key connection key. - * - * @param permissions new permissions - */ - AppPermissionDelegate(const uint32_t connection_key, - const PermissionConsent& permissions, - policy::PolicyHandlerInterface& policy_handler); - - /** - * @brief threadMain run the needed function. - */ - virtual void threadMain(); - - /** - * @brief exitThreadMain do some stuff before exit from thread - * - * @return true in case when thread has been finished properly - */ - virtual void exitThreadMain(); - - private: - uint32_t connection_key_; - PermissionConsent permissions_; - policy::PolicyHandlerInterface& policy_handler_; -}; - -} // namespace policy - -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_APP_PERMISSION_DELEGATE_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "application_manager/policies/external/delegates/app_permission_delegate.h" +#else +#include "application_manager/policies/regular/delegates/app_permission_delegate.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h b/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h index 3dc9ad925c..54e034f916 100644 --- a/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h +++ b/src/components/application_manager/include/application_manager/policies/delegates/statistics_delegate.h @@ -1,86 +1,5 @@ -/* - Copyright (c) 2014, 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_STATISTICS_DELEGATE_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_STATISTICS_DELEGATE_H_ - -#include <string> - -#include "utils/threads/thread.h" -#include "utils/threads/thread_delegate.h" -#include "utils/conditional_variable.h" -#include "application_manager/usage_statistics.h" - -namespace policy { - -class PolicyHandler; - -class StatisticsDelegate : public threads::ThreadDelegate { - enum StatisticType { INCREMENT_GLOBAL, INCREMENT_APP, SET, ADD }; - - public: - StatisticsDelegate(PolicyHandler& policy_handler, - usage_statistics::GlobalCounterId type); - - StatisticsDelegate(PolicyHandler& policy_handler, - const std::string& app_id, - usage_statistics::AppCounterId type); - - StatisticsDelegate(PolicyHandler& policy_handler, - const std::string& app_id, - usage_statistics::AppInfoId type, - const std::string& value); - - StatisticsDelegate(PolicyHandler& policy_handler, - const std::string& app_id, - usage_statistics::AppStopwatchId type, - int32_t timespan_seconds); - - virtual void threadMain(); - - virtual void exitThreadMain(); - - private: - StatisticType type_; - usage_statistics::GlobalCounterId global_counter_; - usage_statistics::AppCounterId app_counter_; - usage_statistics::AppInfoId app_info_; - usage_statistics::AppStopwatchId stop_watch_; - - std::string app_id_; - std::string value_; - int32_t timespan_seconds_; - PolicyHandler& policy_handler_; -}; -} // namespace policy - -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_STATISTICS_DELEGATE_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "application_manager/policies/external/delegates/statistics_delegate.h" +#else +#include "application_manager/policies/regular/delegates/statistics_delegate.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/external/delegates/app_permission_delegate.h b/src/components/application_manager/include/application_manager/policies/external/delegates/app_permission_delegate.h new file mode 100644 index 0000000000..f501598e0f --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/external/delegates/app_permission_delegate.h @@ -0,0 +1,85 @@ +/* + 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_DELEGATES_APP_PERMISSION_DELEGATE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_DELEGATES_APP_PERMISSION_DELEGATE_H_ + +#include "utils/threads/thread.h" +#include "utils/threads/thread_delegate.h" +#include "utils/conditional_variable.h" + +#include "policy/policy_types.h" +#include "application_manager/policies/policy_handler_interface.h" + +namespace policy { +class PolicyHandler; +/** +*@brief The AppPermissionDelegate class allows to call OnAppPermissionConsent +*in async way. +*/ +class AppPermissionDelegate : public threads::ThreadDelegate { + public: + /** + * @brief AppPermissionDelegate constructor, contains parameters + * which will be pass to the called function. + * + * @param connection_key connection key. + * + * @param permissions new permissions + */ + AppPermissionDelegate(const uint32_t connection_key, + const PermissionConsent& permissions, + const ExternalConsentStatus& external_consent_status, + policy::PolicyHandlerInterface& policy_handler); + + /** + * @brief threadMain run the needed function. + */ + virtual void threadMain(); + + /** + * @brief exitThreadMain do some stuff before exit from thread + * + * @return true in case when thread has been finished properly + */ + virtual void exitThreadMain(); + + private: + uint32_t connection_key_; + PermissionConsent permissions_; + ExternalConsentStatus external_consent_status_; + policy::PolicyHandlerInterface& policy_handler_; +}; + +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_DELEGATES_APP_PERMISSION_DELEGATE_H_ diff --git a/src/components/application_manager/include/application_manager/policies/external/delegates/statistics_delegate.h b/src/components/application_manager/include/application_manager/policies/external/delegates/statistics_delegate.h new file mode 100644 index 0000000000..2fe4265f54 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/external/delegates/statistics_delegate.h @@ -0,0 +1,86 @@ +/* + 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_DELEGATES_STATISTICS_DELEGATE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_DELEGATES_STATISTICS_DELEGATE_H_ + +#include <string> + +#include "utils/threads/thread.h" +#include "utils/threads/thread_delegate.h" +#include "utils/conditional_variable.h" +#include "application_manager/usage_statistics.h" + +namespace policy { + +class PolicyHandler; + +class StatisticsDelegate : public threads::ThreadDelegate { + enum StatisticType { INCREMENT_GLOBAL, INCREMENT_APP, SET, ADD }; + + public: + StatisticsDelegate(PolicyHandler& policy_handler, + usage_statistics::GlobalCounterId type); + + StatisticsDelegate(PolicyHandler& policy_handler, + const std::string& app_id, + usage_statistics::AppCounterId type); + + StatisticsDelegate(PolicyHandler& policy_handler, + const std::string& app_id, + usage_statistics::AppInfoId type, + const std::string& value); + + StatisticsDelegate(PolicyHandler& policy_handler, + const std::string& app_id, + usage_statistics::AppStopwatchId type, + int32_t timespan_seconds); + + virtual void threadMain(); + + virtual void exitThreadMain(); + + private: + StatisticType type_; + usage_statistics::GlobalCounterId global_counter_; + usage_statistics::AppCounterId app_counter_; + usage_statistics::AppInfoId app_info_; + usage_statistics::AppStopwatchId stop_watch_; + + std::string app_id_; + std::string value_; + int32_t timespan_seconds_; + PolicyHandler& policy_handler_; +}; +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_DELEGATES_STATISTICS_DELEGATE_H_ diff --git a/src/components/application_manager/include/application_manager/policies/external/policy_event_observer.h b/src/components/application_manager/include/application_manager/policies/external/policy_event_observer.h new file mode 100644 index 0000000000..8c904bf513 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/external/policy_event_observer.h @@ -0,0 +1,62 @@ +/* + 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ + +#include "smart_objects/smart_object.h" +#include "application_manager/event_engine/event_observer.h" +#include "utils/lock.h" + +namespace policy { + +class PolicyHandlerInterface; +class PolicyEventObserver + : public application_manager::event_engine::EventObserver { + public: + explicit PolicyEventObserver( + policy::PolicyHandlerInterface* const policy_handler, + application_manager::event_engine::EventDispatcher& event_dispatcher); + void set_policy_handler(policy::PolicyHandlerInterface* const policy_handler); + void on_event(const application_manager::event_engine::Event& event); + void subscribe_on_event( + const application_manager::event_engine::Event::EventID& event_id, + int32_t hmi_correlation_id = 0); + + private: + sync_primitives::Lock policy_handler_lock_; + PolicyHandlerInterface* policy_handler_; + void ProcessOdometerEvent(const ::smart_objects::SmartObject& message); +}; + +} // namespace policy +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ diff --git a/src/components/application_manager/include/application_manager/policies/policy_event_observer.h b/src/components/application_manager/include/application_manager/policies/policy_event_observer.h index 13f070a1ec..6f2bd37075 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_event_observer.h +++ b/src/components/application_manager/include/application_manager/policies/policy_event_observer.h @@ -1,63 +1,5 @@ -/* - 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ - -#include "application_manager/event_engine/event_observer.h" -#include "utils/lock.h" - -namespace policy { -namespace smart_objects = NsSmartDeviceLink::NsSmartObjects; - -class PolicyHandlerInterface; - -class PolicyEventObserver - : public application_manager::event_engine::EventObserver { - public: - PolicyEventObserver( - policy::PolicyHandlerInterface* const policy_handler, - application_manager::event_engine::EventDispatcher& event_dispatcher); - void set_policy_handler(policy::PolicyHandlerInterface* const policy_handler); - void on_event(const application_manager::event_engine::Event& event); - void subscribe_on_event( - const application_manager::event_engine::Event::EventID& event_id, - int32_t hmi_correlation_id = 0); - - private: - sync_primitives::Lock policy_handler_lock_; - PolicyHandlerInterface* policy_handler_; - void ProcessOdometerEvent(const smart_objects::SmartObject& message); -}; - -} // namespace policy -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#include "application_manager/policies/external/policy_event_observer.h" +#else +#include "application_manager/policies/regular/policy_event_observer.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler.h b/src/components/application_manager/include/application_manager/policies/policy_handler.h index 6f36408444..c8f3bcf888 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_handler.h +++ b/src/components/application_manager/include/application_manager/policies/policy_handler.h @@ -30,8 +30,8 @@ POSSIBILITY OF SUCH DAMAGE. */ -#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_H_ +#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_HANDLER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_HANDLER_H_ #include <string> #include <map> @@ -41,6 +41,7 @@ #include <stdint.h> #include "policy/policy_manager.h" +#include "application_manager/application.h" #include "application_manager/policies/policy_handler_interface.h" #include "application_manager/policies/policy_event_observer.h" #include "application_manager/policies/delegates/statistics_delegate.h" @@ -64,8 +65,9 @@ class ApplicationManager; } namespace policy { + typedef std::vector<uint32_t> AppIds; -typedef std::vector<uint32_t> DeviceHandles; +typedef std::vector<transport_manager::DeviceHandle> DeviceHandles; namespace custom_str = utils::custom_string; class PolicyHandler : public PolicyHandlerInterface, @@ -92,37 +94,119 @@ class PolicyHandler : public PolicyHandlerInterface, virtual void OnPermissionsUpdated(const std::string& policy_app_id, const Permissions& permissions) OVERRIDE; - virtual void OnSnapshotCreated(const BinaryMessage& pt_string) OVERRIDE; - +#ifdef EXTERNAL_PROPRIETARY_MODE + void OnSnapshotCreated(const BinaryMessage& pt_string, + const std::vector<int>& retry_delay_seconds, + uint32_t timeout_exchange) OVERRIDE; +#else // EXTERNAL_PROPRIETARY_MODE + void OnSnapshotCreated(const BinaryMessage& pt_string) OVERRIDE; +#endif // EXTERNAL_PROPRIETARY_MODE virtual bool GetPriority(const std::string& policy_app_id, std::string* priority) const OVERRIDE; - void CheckPermissions(const PTString& app_id, - const PTString& hmi_level, - const PTString& rpc, - const RPCParams& rpc_params, - CheckPermissionResult& result) OVERRIDE; + virtual void CheckPermissions( + const application_manager::ApplicationSharedPtr app, + const PTString& rpc, + const RPCParams& rpc_params, + CheckPermissionResult& result) OVERRIDE; uint32_t GetNotificationsNumber(const std::string& priority) const OVERRIDE; virtual DeviceConsent GetUserConsentForDevice( const std::string& device_id) const OVERRIDE; + + /** + * @brief Sets HMI default type for specified application + * @param application_id ID application + * @param app_types list of HMI types + */ + void SetDefaultHmiTypes(const std::string& application_id, + const smart_objects::SmartObject* app_types) OVERRIDE; + + /** + * Checks if application has HMI type + * @param application_id ID application + * @param hmi HMI type to check + * @param app_types additional list of HMI type to search in it + * @return true if hmi is contained in policy or app_types + */ + bool CheckHMIType(const std::string& application_id, + mobile_apis::AppHMIType::eType hmi, + const smart_objects::SmartObject* app_types) OVERRIDE; + + /** + * Notifies about changing HMI level + * @param device_id unique identifier of device + * @param policy_app_id unique identifier of application in policy + * @param hmi_level default HMI level for this application + */ + void OnUpdateHMILevel(const std::string& device_id, + const std::string& policy_app_id, + const std::string& hmi_level) OVERRIDE; + + /** + * Checks if module for application is present in policy table + * @param app_id id of application + * @param module type + * @return true if module is present, otherwise - false + */ + bool CheckModule(const PTString& app_id, const PTString& module) OVERRIDE; + + /** + * @brief Notifies Remote apps about change in permissions + * @param device_id Device on which app is running + * @param application_id ID of app whose permissions are changed + */ + void OnRemoteAppPermissionsChanged( + const std::string& device_id, const std::string& application_id) OVERRIDE; + + /** + * @brief Notifies Remote apps about change in HMI status + * @param device_id Device on which app is running + * @param policy_app_id ID of application + * @param hmi_level new HMI level for this application + */ + void OnUpdateHMIStatus(const std::string& device_id, + const std::string& policy_app_id, + const std::string& hmi_level) OVERRIDE; + + /** + * Gets all allowed module types + * @param app_id unique identifier of application + * @param list of allowed module types + * @return true if application has allowed modules + */ + bool GetModuleTypes(const std::string& policy_app_id, + std::vector<std::string>* modules) const OVERRIDE; + bool GetDefaultHmi(const std::string& policy_app_id, std::string* default_hmi) const OVERRIDE; bool GetInitialAppData(const std::string& application_id, StringArray* nicknames = NULL, StringArray* app_hmi_types = NULL) OVERRIDE; - void GetServiceUrls(const std::string& service_type, - EndpointUrls& end_points) OVERRIDE; + void GetUpdateUrls(const std::string& service_type, + EndpointUrls& out_end_points) OVERRIDE; + void GetUpdateUrls(const uint32_t service_type, + EndpointUrls& out_end_points) OVERRIDE; virtual std::string GetLockScreenIconUrl() const OVERRIDE; - void ResetRetrySequence() OVERRIDE; uint32_t NextRetryTimeout() OVERRIDE; - int TimeoutExchange() OVERRIDE; + + /** + * Gets timeout to wait until receive response + * @return timeout in seconds + */ + uint32_t TimeoutExchangeSec() const OVERRIDE; + + /** + * Gets timeout to wait until receive response + * @return timeout in miliseconds + */ + uint32_t TimeoutExchangeMSec() const OVERRIDE; void OnExceededTimeout() OVERRIDE; void OnSystemReady() OVERRIDE; void PTUpdatedAt(Counters counter, int value) OVERRIDE; void add_listener(PolicyHandlerObserver* listener) OVERRIDE; void remove_listener(PolicyHandlerObserver* listener) OVERRIDE; - utils::SharedPtr<usage_statistics::StatisticsManager> GetStatisticManager() + std::shared_ptr<usage_statistics::StatisticsManager> GetStatisticManager() const OVERRIDE; /** @@ -150,11 +234,11 @@ class PolicyHandler : public PolicyHandlerInterface, /** * @brief Process user consent on mobile data connection access - * @param Device id or empty string, if concern to all SDL functionality - * @param User consent from response + * @param is_allowed - user consent from response + * @param device_mac - mac adress of device */ void OnAllowSDLFunctionalityNotification( - bool is_allowed, const std::string& device_id) OVERRIDE; + bool is_allowed, const std::string& device_mac) OVERRIDE; /** * @brief Increment counter for ignition cycles @@ -185,14 +269,32 @@ class PolicyHandler : public PolicyHandlerInterface, void SetDeviceInfo(const std::string& device_id, const DeviceInfo& device_info) OVERRIDE; - /** - * @brief Store user-changed permissions consent to DB - * @param connection_key Connection key of application or 0, if permissions - * should be applied to all applications - * @param permissions User-changed group permissions consent - */ +/** + * @brief Store user-changed permissions consent to DB + * @param connection_key Connection key of application or 0, if permissions + * should be applied to all applications + * @param permissions User-changed group permissions consent + */ + +/** + * @brief Processes permissions changes received from system via + * OnAppPermissionConsent notification + * @param connection_key Connection key of application, 0 if no key has been + * provided by notification + * @param permissions Structure containing group permissions changes + * @param external_consent_status Structure containig customer connectivity + * settings + * changes + */ +#ifdef EXTERNAL_PROPRIETARY_MODE + void OnAppPermissionConsent( + const uint32_t connection_key, + const PermissionConsent& permissions, + const ExternalConsentStatus& external_consent_status) OVERRIDE; +#else void OnAppPermissionConsent(const uint32_t connection_key, const PermissionConsent& permissions) OVERRIDE; +#endif /** * @brief Get appropriate message parameters and send them with response @@ -287,8 +389,9 @@ class PolicyHandler : public PolicyHandlerInterface, void OnSystemError(int code) OVERRIDE; /** - * @brief Choose application id to be used for snapshot sending - * @return Application id or 0, if there are no applications registered + * @brief Chooses random application id to be used for snapshot sending + * considering HMI level + * @return Application id or 0, if there are no suitable applications */ uint32_t GetAppIdForSending() const OVERRIDE; @@ -300,7 +403,9 @@ class PolicyHandler : public PolicyHandlerInterface, virtual void OnCertificateUpdated( const std::string& certificate_data) OVERRIDE; - +#ifdef EXTERNAL_PROPRIETARY_MODE + void OnCertificateDecrypted(bool is_succeeded) OVERRIDE; +#endif // EXTERNAL_PROPRIETARY_MODE virtual bool CanUpdate() OVERRIDE; virtual void OnDeviceConsentChanged(const std::string& device_id, @@ -318,8 +423,12 @@ class PolicyHandler : public PolicyHandlerInterface, * @brief Allows to add new or update existed application during * registration process * @param application_id The policy aplication id. + * @param hmi_types list of hmi types + * @return function that will notify update manager about new application */ - void AddApplication(const std::string& application_id) OVERRIDE; + StatusNotifier AddApplication( + const std::string& application_id, + const rpc::policy_table_interface_base::AppHmiTypes& hmi_types) OVERRIDE; /** * Checks whether application is revoked @@ -354,7 +463,16 @@ class PolicyHandler : public PolicyHandlerInterface, /** * @brief Handler on applications search completed */ - void OnAppsSearchCompleted() OVERRIDE; + void OnAppsSearchCompleted(const bool trigger_ptu) OVERRIDE; + + /** + * @brief OnAppRegisteredOnMobile allows 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. + */ + void OnAppRegisteredOnMobile(const std::string& application_id) OVERRIDE; /** * @brief Checks if certain request type is allowed for application @@ -367,6 +485,32 @@ class PolicyHandler : public PolicyHandlerInterface, mobile_apis::RequestType::eType type) const OVERRIDE; /** + * @brief Checks if certain request subtype is allowed for application + * @param policy_app_id Unique applicaion id + * @param request_subtype Request subtype + * @return true, if allowed, otherwise - false + */ + bool IsRequestSubTypeAllowed( + const std::string& policy_app_id, + const std::string& request_subtype) const OVERRIDE; + + /** + * @brief Gets application request types state + * @param policy_app_id Unique application id + * @return request types state + */ + RequestType::State GetAppRequestTypeState( + const std::string& policy_app_id) const OVERRIDE; + + /** + * @brief Gets application request subtypes state + * @param policy_app_id Unique application id + * @return request subtypes state + */ + RequestSubType::State GetAppRequestSubTypeState( + const std::string& policy_app_id) const OVERRIDE; + + /** * @brief Gets application request types * @param policy_app_id Unique application id * @return request types @@ -375,33 +519,40 @@ class PolicyHandler : public PolicyHandlerInterface, const std::string& policy_app_id) const OVERRIDE; /** + * @brief Gets application request subtypes + * @param policy_app_id Unique application id + * @return app request subtypes + */ + const std::vector<std::string> GetAppRequestSubTypes( + const std::string& policy_app_id) const OVERRIDE; + + /** * @brief Gets vehicle information * @return Structure with vehicle information */ const VehicleInfo GetVehicleInfo() const OVERRIDE; +#ifdef EXTERNAL_PROPRIETARY_MODE /** - * @brief OnAppRegisteredOnMobile allows 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. + * @brief Gets meta information + * @return meta information */ - void OnAppRegisteredOnMobile(const std::string& application_id) OVERRIDE; + const policy::MetaInfo GetMetaInfo() const OVERRIDE; +#endif // EXTERNAL_PROPRIETARY_MODE // TODO(AKutsan) REMOVE THIS UGLY HOTFIX - virtual void Increment(usage_statistics::GlobalCounterId type) OVERRIDE; - virtual void Increment(const std::string& app_id, - usage_statistics::AppCounterId type) OVERRIDE; - virtual void Set(const std::string& app_id, - usage_statistics::AppInfoId type, - const std::string& value) OVERRIDE; - virtual void Add(const std::string& app_id, - usage_statistics::AppStopwatchId type, - int32_t timespan_seconds) OVERRIDE; + void Increment(usage_statistics::GlobalCounterId type) OVERRIDE; + void Increment(const std::string& app_id, + usage_statistics::AppCounterId type) OVERRIDE; + void Set(const std::string& app_id, + usage_statistics::AppInfoId type, + const std::string& value) OVERRIDE; + void Add(const std::string& app_id, + usage_statistics::AppStopwatchId type, + int32_t timespan_seconds) OVERRIDE; #ifdef BUILD_TESTS - void SetPolicyManager(utils::SharedPtr<PolicyManager> pm) { + void SetPolicyManager(std::shared_ptr<PolicyManager> pm) { policy_manager_ = pm; } #endif // BUILD_TESTS @@ -412,6 +563,17 @@ class PolicyHandler : public PolicyHandlerInterface, const PolicySettings& get_settings() const OVERRIDE; + virtual void OnPTUFinished(const bool ptu_result) OVERRIDE; + + /** + * @brief OnDeviceSwitching Notifies policy manager on device switch event so + * policy permissions should be processed accordingly + * @param device_id_from Id of device being switched + * @param device_id_to Id of device on the new transport + */ + void OnDeviceSwitching(const std::string& device_id_from, + const std::string& device_id_to) FINAL; + protected: /** * Starts next retry exchange policy table @@ -439,21 +601,68 @@ class PolicyHandler : public PolicyHandlerInterface, */ bool CheckStealFocus(const std::string& policy_app_id) const; - /** - * @brief OnAppPermissionConsentInternal reacts on permission changing - * - * @param connection_key connection key - * - * @param permissions new permissions. - */ - void OnAppPermissionConsentInternal(const uint32_t connection_key, - PermissionConsent& permissions) OVERRIDE; +/** + * @brief Processes data received via OnAppPermissionChanged notification + * from. Being started asyncronously from AppPermissionDelegate class. + * Sets updated permissions and ExternalConsent for registered applications + * and + * applications which already have appropriate group assigned which related to + * devices already known by policy + * @param connection_key Connection key of application, 0 if no key has been + * provided within notification + * @param external_consent_status Customer connectivity settings changes to + * process + * @param permissions Permissions changes to process + */ +#ifdef EXTERNAL_PROPRIETARY_MODE + void OnAppPermissionConsentInternal( + const uint32_t connection_key, + const ExternalConsentStatus& external_consent_status, + PermissionConsent& out_permissions) OVERRIDE; +#else + void OnAppPermissionConsentInternal( + const uint32_t connection_key, + PermissionConsent& out_permissions) OVERRIDE; +#endif + + /** + * @brief Updates HMI level for specified application and send notification + * @param app application where HMI level was changed + * @param level new HMI level + */ + void UpdateHMILevel(application_manager::ApplicationSharedPtr app, + mobile_apis::HMILevel::eType level); + std::vector<std::string> GetDevicesIds( + const std::string& policy_app_id) OVERRIDE; /** * @brief Sets days after epoch on successful policy update */ void SetDaysAfterEpoch(); + /** + * @brief Link all currently registered applications + */ + void LinkAppsToDevice(); + + typedef std::vector<application_manager::ApplicationSharedPtr> Applications; + + /** + * @brief Checks application registration status (SDL4.0) and device consent + * to find out whether application is suitable + * @param value Item from applications collection + * @return true if application is suitable, otherwise - false + */ + bool IsAppSuitableForPolicyUpdate(const Applications::value_type value) const; + + /** + * @brief Chooses random application from list using + * IsAppSuitableForPolicyUpdate + * @param app_list Application collection + * @return Application id if suitable is found, otherwise - zero + */ + uint32_t ChooseRandomAppForPolicyUpdate(Applications& app_list) const; + private: class StatisticManagerImpl : public usage_statistics::StatisticsManager { public: @@ -462,26 +671,26 @@ class PolicyHandler : public PolicyHandlerInterface, DCHECK(policy_handler_); } // TODO(AKutsan) REMOVE THIS UGLY HOTFIX - virtual void Increment(usage_statistics::GlobalCounterId type) { + void Increment(usage_statistics::GlobalCounterId type) OVERRIDE { policy_handler_->AsyncRun(new StatisticsDelegate(*policy_handler_, type)); } void Increment(const std::string& app_id, - usage_statistics::AppCounterId type) { + usage_statistics::AppCounterId type) OVERRIDE { policy_handler_->AsyncRun( new StatisticsDelegate(*policy_handler_, app_id, type)); } void Set(const std::string& app_id, usage_statistics::AppInfoId type, - const std::string& value) { + const std::string& value) OVERRIDE { policy_handler_->AsyncRun( new StatisticsDelegate(*policy_handler_, app_id, type, value)); } void Add(const std::string& app_id, usage_statistics::AppStopwatchId type, - int32_t timespan_seconds) { + int32_t timespan_seconds) OVERRIDE { policy_handler_->AsyncRun(new StatisticsDelegate( *policy_handler_, app_id, type, timespan_seconds)); } @@ -489,14 +698,43 @@ class PolicyHandler : public PolicyHandlerInterface, private: PolicyHandler* policy_handler_; }; - +#ifdef EXTERNAL_PROPRIETARY_MODE + void OnEmptyCertificateArrived() const; +#endif // EXTERNAL_PROPRIETARY_MODE bool SaveSnapshot(const BinaryMessage& pt_string, std::string& snap_path); + + /** + * @brief Collects permissions for all currently registered applications on + * all devices + * @return consolidated permissions list or empty list if no + * applications/devices currently present + */ + std::vector<FunctionalGroupPermission> CollectRegisteredAppsPermissions(); + + /** + * @brief Collects permissions for application with certain connection key + * @param connection_key Connection key of application to look for + * @return list of application permissions or empty list if no such + * application found + */ + std::vector<FunctionalGroupPermission> CollectAppPermissions( + const uint32_t connection_key); + + private: static const std::string kLibrary; + + /** + * @brief Collects currently registered applications ids linked to their + * device id + * @param out_links Collection of device_id-to-app_id links + */ + void GetRegisteredLinks(std::map<std::string, std::string>& out_links) const; + + private: mutable sync_primitives::RWLock policy_manager_lock_; - utils::SharedPtr<PolicyManager> policy_manager_; + std::shared_ptr<PolicyManager> policy_manager_; void* dl_handle_; - AppIds last_used_app_ids_; - utils::SharedPtr<PolicyEventObserver> event_observer_; + std::shared_ptr<PolicyEventObserver> event_observer_; uint32_t last_activated_app_id_; /** @@ -508,25 +746,36 @@ class PolicyHandler : public PolicyHandlerInterface, typedef std::list<PolicyHandlerObserver*> HandlersCollection; HandlersCollection listeners_; - sync_primitives::Lock listeners_lock_; + mutable sync_primitives::Lock listeners_lock_; /** - * @brief Application-to-device map is used for getting/setting user consents - * for all apps + * @brief Application-to-device links are used for collecting their current + * consents to provide for HMI request and process response with possible + * changes done by user */ std::map<std::string, std::string> app_to_device_link_; // Lock for app to device list - sync_primitives::Lock app_to_device_link_lock_; + sync_primitives::RecursiveLock app_to_device_link_lock_; - utils::SharedPtr<StatisticManagerImpl> statistic_manager_impl_; + std::shared_ptr<StatisticManagerImpl> statistic_manager_impl_; const PolicySettings& settings_; application_manager::ApplicationManager& application_manager_; friend class AppPermissionDelegate; + /** + * @brief Checks if the application with the given policy + * application id is registered or it is default id + * @param app_idx Application idx from EndpointUrls vector + * @param urls EndpointUrls vector + * @return TRUE if the vector with URLs with given idx is not empty + * and is related to a registered application or these are default URLs, + * otherwise FALSE + */ + bool IsUrlAppIdValid(const uint32_t app_idx, const EndpointUrls& urls) const; DISALLOW_COPY_AND_ASSIGN(PolicyHandler); }; } // namespace policy -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_H_ +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_HANDLER_H_ diff --git a/src/components/application_manager/include/application_manager/policies/policy_retry_sequence.h b/src/components/application_manager/include/application_manager/policies/policy_retry_sequence.h index f1a9ff55b8..334a7b3a2d 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_retry_sequence.h +++ b/src/components/application_manager/include/application_manager/policies/policy_retry_sequence.h @@ -1,54 +1,5 @@ -/* - 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_RETRY_SEQUENCE_H_ -#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_RETRY_SEQUENCE_H_ - -#include "utils/threads/thread_delegate.h" - -namespace policy { - -class PolicyHandler; - -class RetrySequence : public threads::ThreadDelegate { - public: - explicit RetrySequence(PolicyHandler* const policy_handler); - void threadMain(); - - private: - PolicyHandler* const policy_handler_; - void StartNextRetry(); -}; - -} // namespace policy - -#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_RETRY_SEQUENCE_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#error "policy_handler_observer.h is not available in policy external" +#else +#include "application_manager/policies/regular/policy_handler_observer.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/pt_exchange_handler.h b/src/components/application_manager/include/application_manager/policies/pt_exchange_handler.h index 4e543eae96..81c5a708f2 100644 --- a/src/components/application_manager/include/application_manager/policies/pt_exchange_handler.h +++ b/src/components/application_manager/include/application_manager/policies/pt_exchange_handler.h @@ -1,47 +1,5 @@ -/* - 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_PT_EXCHANGE_HANDLER_H_ -#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_PT_EXCHANGE_HANDLER_H_ - -#include "policy/policy_manager.h" - -namespace policy { -class PTExchangeHandler { - public: - virtual ~PTExchangeHandler(){}; - virtual void Start() = 0; - virtual void Stop() = 0; -}; -} // namespace policy - -#endif // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_PT_EXCHANGE_HANDLER_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#error "pt_exchange_handler.h is not available in policy external" +#else +#include "application_manager/policies/regular/pt_exchange_handler.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_ext.h b/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_ext.h index 05aec0c3e9..962b9c4009 100644 --- a/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_ext.h +++ b/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_ext.h @@ -1,52 +1,5 @@ -/* - 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_PT_EXCHANGE_HANDLER_EXT_H_ -#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_PT_EXCHANGE_HANDLER_EXT_H_ - -#include "application_manager/policies/pt_exchange_handler.h" -#include "application_manager/policies/policy_handler.h" - -namespace policy { -class PTExchangeHandlerExt : public PTExchangeHandler { - public: - PTExchangeHandlerExt(PolicyHandler* policy_handler); - ~PTExchangeHandlerExt(); - virtual void Start(); - virtual void Stop(); - - private: - PolicyHandler* policy_handler_; -}; -} // namespace policy - -#endif // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_PT_EXCHANGE_HANDLER_EXT_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#error "pt_exchange_handler_ext.h is not available in policy external" +#else +#include "application_manager/policies/regular/pt_exchange_handler_ext.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_impl.h b/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_impl.h index 29c74aa96e..004e87461e 100644 --- a/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_impl.h +++ b/src/components/application_manager/include/application_manager/policies/pt_exchange_handler_impl.h @@ -1,61 +1,5 @@ -/* - 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_PT_EXCHANGE_IMPL_H_ -#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_PT_EXCHANGE_IMPL_H_ - -#include "application_manager/policies/pt_exchange_handler.h" -#include "utils/lock.h" -#include "utils/threads/thread.h" - -namespace policy { - -class PolicyHandler; - -class PTExchangeHandlerImpl : public PTExchangeHandler { - public: - PTExchangeHandlerImpl(PolicyHandler* handler); - virtual ~PTExchangeHandlerImpl(); - virtual void Start(); - virtual void Stop(); - - protected: - PolicyHandler* policy_handler_; - threads::Thread* retry_sequence_; - sync_primitives::Lock retry_sequence_lock_; - - friend class RetrySequence; -}; - -} // namespace policy - -#endif // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_PT_EXCHANGE_IMPL_H_ +#ifdef EXTERNAL_PROPRIETARY_MODE +#error "pt_exchange_handler_impl.h is not available in policy external" +#else +#include "application_manager/policies/regular/pt_exchange_handler_impl.h" +#endif diff --git a/src/components/application_manager/include/application_manager/policies/regular/delegates/app_permission_delegate.h b/src/components/application_manager/include/application_manager/policies/regular/delegates/app_permission_delegate.h new file mode 100644 index 0000000000..6913f5038e --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/delegates/app_permission_delegate.h @@ -0,0 +1,82 @@ +/* + Copyright (c) 2014, 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_APP_PERMISSION_DELEGATE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_APP_PERMISSION_DELEGATE_H_ + +#include "utils/threads/thread.h" +#include "utils/threads/thread_delegate.h" +#include "utils/conditional_variable.h" + +#include "policy/policy_types.h" +#include "application_manager/policies/policy_handler_interface.h" + +namespace policy { +/** +*@brief The AppPermissionDelegate class allows to call OnAppPermissionConsent +*in async way. +*/ +class AppPermissionDelegate : public threads::ThreadDelegate { + public: + /** + * @brief AppPermissionDelegate constructor, contains parameters + * which will be pass to the called function. + * + * @param connection_key connection key. + * + * @param permissions new permissions + */ + AppPermissionDelegate(const uint32_t connection_key, + const PermissionConsent& permissions, + policy::PolicyHandlerInterface& policy_handler); + + /** + * @brief threadMain run the needed function. + */ + virtual void threadMain(); + + /** + * @brief exitThreadMain do some stuff before exit from thread + * + * @return true in case when thread has been finished properly + */ + virtual void exitThreadMain(); + + private: + uint32_t connection_key_; + PermissionConsent permissions_; + policy::PolicyHandlerInterface& policy_handler_; +}; + +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_APP_PERMISSION_DELEGATE_H_ diff --git a/src/components/application_manager/include/application_manager/policies/regular/delegates/statistics_delegate.h b/src/components/application_manager/include/application_manager/policies/regular/delegates/statistics_delegate.h new file mode 100644 index 0000000000..3dc9ad925c --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/delegates/statistics_delegate.h @@ -0,0 +1,86 @@ +/* + Copyright (c) 2014, 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_STATISTICS_DELEGATE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_STATISTICS_DELEGATE_H_ + +#include <string> + +#include "utils/threads/thread.h" +#include "utils/threads/thread_delegate.h" +#include "utils/conditional_variable.h" +#include "application_manager/usage_statistics.h" + +namespace policy { + +class PolicyHandler; + +class StatisticsDelegate : public threads::ThreadDelegate { + enum StatisticType { INCREMENT_GLOBAL, INCREMENT_APP, SET, ADD }; + + public: + StatisticsDelegate(PolicyHandler& policy_handler, + usage_statistics::GlobalCounterId type); + + StatisticsDelegate(PolicyHandler& policy_handler, + const std::string& app_id, + usage_statistics::AppCounterId type); + + StatisticsDelegate(PolicyHandler& policy_handler, + const std::string& app_id, + usage_statistics::AppInfoId type, + const std::string& value); + + StatisticsDelegate(PolicyHandler& policy_handler, + const std::string& app_id, + usage_statistics::AppStopwatchId type, + int32_t timespan_seconds); + + virtual void threadMain(); + + virtual void exitThreadMain(); + + private: + StatisticType type_; + usage_statistics::GlobalCounterId global_counter_; + usage_statistics::AppCounterId app_counter_; + usage_statistics::AppInfoId app_info_; + usage_statistics::AppStopwatchId stop_watch_; + + std::string app_id_; + std::string value_; + int32_t timespan_seconds_; + PolicyHandler& policy_handler_; +}; +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_DELEGATES_STATISTICS_DELEGATE_H_ diff --git a/src/components/application_manager/include/application_manager/policies/regular/policy_event_observer.h b/src/components/application_manager/include/application_manager/policies/regular/policy_event_observer.h new file mode 100644 index 0000000000..f4924111b3 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/policy_event_observer.h @@ -0,0 +1,62 @@ +/* + 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ + +#include "application_manager/event_engine/event_observer.h" +#include "utils/lock.h" + +namespace policy { + +class PolicyHandlerInterface; + +class PolicyEventObserver + : public application_manager::event_engine::EventObserver { + public: + PolicyEventObserver( + policy::PolicyHandlerInterface* const policy_handler, + application_manager::event_engine::EventDispatcher& event_dispatcher); + void set_policy_handler(policy::PolicyHandlerInterface* const policy_handler); + void on_event(const application_manager::event_engine::Event& event); + void subscribe_on_event( + const application_manager::event_engine::Event::EventID& event_id, + int32_t hmi_correlation_id = 0); + + private: + sync_primitives::Lock policy_handler_lock_; + PolicyHandlerInterface* policy_handler_; + void ProcessOdometerEvent(const ::smart_objects::SmartObject& message); +}; + +} // namespace policy +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICIES_POLICY_EVENT_OBSERVER_H_ diff --git a/src/components/application_manager/include/application_manager/policies/policy_handler_observer.h b/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h index 794da0cdfb..07d234f036 100644 --- a/src/components/application_manager/include/application_manager/policies/policy_handler_observer.h +++ b/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h @@ -43,9 +43,13 @@ class PolicyHandlerObserver { public: virtual void OnUpdateHMIAppType( std::map<std::string, std::vector<std::string> > app_hmi_types) {} + virtual bool OnCertificateUpdated(const std::string& certificate_data) { return false; } + + virtual void OnPTUFinished(const bool ptu_result) {} + virtual ~PolicyHandlerObserver() {} }; } // namespace policy diff --git a/src/components/application_manager/include/application_manager/policies/regular/policy_retry_sequence.h b/src/components/application_manager/include/application_manager/policies/regular/policy_retry_sequence.h new file mode 100644 index 0000000000..f1a9ff55b8 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/policy_retry_sequence.h @@ -0,0 +1,54 @@ +/* + 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_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_RETRY_SEQUENCE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_RETRY_SEQUENCE_H_ + +#include "utils/threads/thread_delegate.h" + +namespace policy { + +class PolicyHandler; + +class RetrySequence : public threads::ThreadDelegate { + public: + explicit RetrySequence(PolicyHandler* const policy_handler); + void threadMain(); + + private: + PolicyHandler* const policy_handler_; + void StartNextRetry(); +}; + +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_RETRY_SEQUENCE_H_ |