diff options
15 files changed, 1298 insertions, 0 deletions
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/regular/policy_handler_observer.h b/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h new file mode 100644 index 0000000000..794da0cdfb --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/policy_handler_observer.h @@ -0,0 +1,53 @@ +/* + 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_HANDLER_OBSERVER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_OBSERVER_H_ + +#include <vector> +#include <string> +#include <map> + +namespace policy { + +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 ~PolicyHandlerObserver() {} +}; +} // namespace policy + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_POLICY_HANDLER_OBSERVER_H_ 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_ diff --git a/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler.h b/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler.h new file mode 100644 index 0000000000..4e543eae96 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler.h @@ -0,0 +1,47 @@ +/* + 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_ diff --git a/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler_ext.h b/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler_ext.h new file mode 100644 index 0000000000..05aec0c3e9 --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler_ext.h @@ -0,0 +1,52 @@ +/* + 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_ diff --git a/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler_impl.h b/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler_impl.h new file mode 100644 index 0000000000..29c74aa96e --- /dev/null +++ b/src/components/application_manager/include/application_manager/policies/regular/pt_exchange_handler_impl.h @@ -0,0 +1,61 @@ +/* + 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_ diff --git a/src/components/include/policy/policy_regular/policy/policy_settings.h b/src/components/include/policy/policy_regular/policy/policy_settings.h new file mode 100644 index 0000000000..7e5b7d6f93 --- /dev/null +++ b/src/components/include/policy/policy_regular/policy/policy_settings.h @@ -0,0 +1,42 @@ +#ifndef POLICY_HANDLER_SETTINGS_H +#define POLICY_HANDLER_SETTINGS_H +#include <string> +#include <stdint.h> + +namespace policy { +class PolicySettings { + public: + /** + * @brief Should Policy be turned off? (Library not loaded) + * @return Flag + */ + virtual bool enable_policy() const = 0; + /* + * @brief Path to preloaded policy file + */ + virtual const std::string& preloaded_pt_file() const = 0; + + /** + * @brief Returns application storage path + */ + virtual const std::string& app_storage_folder() const = 0; + + virtual uint16_t attempts_to_open_policy_db() const = 0; + + virtual uint16_t open_attempt_timeout_ms() const = 0; + + /** + * @brief Path to policies snapshot file + * @return file path + */ + virtual const std::string& policies_snapshot_file_name() const = 0; + + /** + * @brief Returns system files folder path + */ + virtual const std::string& system_files_path() const = 0; + + virtual ~PolicySettings() {} +}; +} // namespace policy +#endif // POLICY_HANDLER_SETTINGS_H diff --git a/src/components/include/policy/policy_regular/policy/policy_types.h b/src/components/include/policy/policy_regular/policy/policy_types.h new file mode 100644 index 0000000000..f725f1c619 --- /dev/null +++ b/src/components/include/policy/policy_regular/policy/policy_types.h @@ -0,0 +1,318 @@ +/* + 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_POLICY_TYPES_H_ +#define SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_TYPES_H_ + +#include <string> +#include <vector> +#include <map> +#include <set> +#include "utils/shared_ptr.h" +#include "utils/helpers.h" + +namespace policy { + +// TODO(PV): specify errors +enum PolicyErrorEnum {}; + +const std::string kDefaultDeviceMacAddress = "00:00:00:00:00:00"; +const std::string kDefaultDeviceName = "MyDevice"; +const std::string kDefaultDeviceConnectionType = "UNKNOWN"; + +/** + * @brief Constants for special ids in application policies section of + * policy table + */ +const std::string kPreDataConsentId = "pre_DataConsent"; +const std::string kDefaultId = "default"; +const std::string kDeviceId = "device"; + +/* + * @brief Status of policy table update + */ +enum PolicyTableStatus { + StatusUpToDate = 0, + StatusUpdatePending, + StatusUpdateRequired, + StatusUnknown +}; + +// Code generator uses String class name, so this typedef was renamed to PTSring +typedef std::string PTString; +typedef std::vector<uint8_t> BinaryMessage; +typedef utils::SharedPtr<BinaryMessage> BinaryMessageSptr; + +typedef std::string HMILevel; +typedef std::string Parameter; +typedef std::string RpcName; +typedef std::set<std::string> RPCParams; + +typedef std::map<std::string, std::set<policy::HMILevel> > HMIPermissions; +typedef std::map<std::string, std::set<policy::Parameter> > + ParameterPermissions; + +struct RpcPermissions { + HMIPermissions hmi_permissions; + ParameterPermissions parameter_permissions; +}; + +typedef std::map<RpcName, RpcPermissions> Permissions; + +/** + * @brief Typedef for use with AllowApp request/notification + */ +typedef std::vector<std::string> PermissionsList; + +/** + * @brief Typedef for getting initial application data, e.g. nickname list + */ +typedef std::vector<std::string> StringArray; + +enum PermitResult { kRpcAllowed = 0, kRpcDisallowed, kRpcUserDisallowed }; + +/** + * @struct Stores result of check: + * if HMI Level was allowed for RPC to work in + * and list of parameters allowed for RPC if specified in PT. + */ +struct CheckPermissionResult { + CheckPermissionResult() : hmi_level_permitted(kRpcDisallowed) {} + + PermitResult hmi_level_permitted; + RPCParams list_of_allowed_params; + RPCParams list_of_disallowed_params; + RPCParams list_of_undefined_params; +}; + +/** + @struct Holds Url string and optional policy app id. + */ +struct EndpointData { + explicit EndpointData(const std::string& url_string = "") + : app_id("default") { + if (false == url_string.empty()) { + url.push_back(url_string); + } + } + std::vector<std::string> url; + std::string app_id; +}; + +typedef std::vector<EndpointData> EndpointUrls; + +/** + * @brief Struct contains device data to be used for dialogs, generation of IDs + */ +struct DeviceParams { + DeviceParams() + : device_name(kDefaultDeviceName) + , device_mac_address(kDefaultDeviceMacAddress) + , device_connection_type(kDefaultDeviceConnectionType) + , device_handle(0) {} + + std::string device_name; + std::string device_mac_address; + std::string device_connection_type; + uint32_t device_handle; +}; + +/** + * @brief User consent for device data usage + */ +enum DeviceConsent { + kDeviceAllowed = 0, + kDeviceDisallowed, + kDeviceHasNoConsent +}; + +/** + * @brief Struct contains parameters, which can be received during application + * registration and should be stored in policy table + */ +struct DeviceInfo { + DeviceInfo() : max_number_rfcom_ports(0) {} + + std::string hardware; + std::string firmware_rev; + std::string os; + std::string os_ver; + std::string carrier; + uint32_t max_number_rfcom_ports; + std::string connection_type; + + void AdoptDeviceType(const std::string& deviceType) { + connection_type = "USB_serial_number"; + using namespace helpers; + static const std::string bluetooth("BLUETOOTH"); + static const std::string wifi("WIFI"); + if (Compare<std::string, EQ, ONE>(deviceType, bluetooth, wifi)) { + connection_type.assign("BTMAC"); + } + } +}; + +/** + * @brief User consent for functional group + */ +enum GroupConsent { kGroupAllowed = 0, kGroupDisallowed, kGroupUndefined }; + +/** + * @brief Contains user permission for RPC functional group with specific name + * and id from DB + */ +struct FunctionalGroupPermission { + FunctionalGroupPermission() : group_id(0), state(kGroupUndefined) {} + + bool operator==(const FunctionalGroupPermission& rhs) { + if (this->group_id == rhs.group_id && + this->group_alias == rhs.group_alias && + this->group_name == rhs.group_name) { + return true; + } + return false; + } + + std::string group_alias; + std::string group_name; + int32_t group_id; + GroupConsent state; +}; + +/** + * @brief Stores data to be sent to HMI on application permissions change + */ +struct AppPermissions { + AppPermissions(const std::string& app_id) + : application_id(app_id) + , isAppPermissionsRevoked(false) + , appRevoked(false) + , appPermissionsConsentNeeded(false) + , appUnauthorized(false) + , requestTypeChanged(false) {} + + std::string application_id; + bool isAppPermissionsRevoked; + std::vector<policy::FunctionalGroupPermission> appRevokedPermissions; + bool appRevoked; + bool appPermissionsConsentNeeded; + bool appUnauthorized; + bool isSDLAllowed; + std::string priority; + DeviceParams deviceInfo; + bool requestTypeChanged; + std::vector<std::string> requestType; +}; + +/** + * @brief Contains parameters for user-defined consent for appication + * functional groups on given device + */ +struct PermissionConsent { + std::string device_id; + std::string policy_app_id; + std::vector<FunctionalGroupPermission> group_permissions; + std::string consent_source; +}; + +/** + * @brief Contain data for GetUserFriendyMessage response + */ +struct UserFriendlyMessage { + std::string message_code; +}; + +/** + * @brief Types of functional groups in policy table + */ +enum GroupType { + kTypeDefault = 0, // groups assigned to 'default' permissions section + kTypeAllowed, // groups allowed by user for specific application + kTypeDisallowed, // groups disallowed by user for specific application + kTypeUnconsented, // groups disallowed by default but consent may be changed + // by user + kTypePreconsented, // groups allowed for specific application without + // user consent by default (could be changed by user) + kTypeGeneral, // groups assigned to specific application + kTypePreDataConsented, // groups assigned to 'pre_DataConsent' permissions + // section + kTypeDevice // groups assigned to 'device' permissions section +}; + +/** + * @brief Array of functional group id from DB + */ +typedef std::vector<int32_t> FunctionalGroupIDs; + +/** + * @brief Array of functional group ids sorted by types + */ +typedef std::map<GroupType, FunctionalGroupIDs> FunctionalIdType; + +/** + * @brief Array of functional group ids binded to user_consent_prompt (e.g. + * VehicleData) and group name (e.g. VehicleData-4) + */ +typedef std::map<uint32_t, std::pair<std::string, std::string> > + FunctionalGroupNames; + +/** + * @brief Array of device ids, which are an identifiers in policy table + */ +typedef std::vector<std::string> DeviceIds; + +/** + * @brief Counters that calculated on receiving of succesful update + */ +enum Counters { KILOMETERS, DAYS_AFTER_EPOCH }; + +/** + * @struct Vehicle information + */ +struct VehicleInfo { + std::string vehicle_make; + std::string vehicle_model; + std::string vehicle_year; +}; + +/** + * @brief The MetaInfo information + */ +struct MetaInfo { + std::string ccpu_version; + std::string wers_country_code; + std::string language; +}; + +} // namespace policy + +#endif // SRC_COMPONENTS_POLICY_INCLUDE_POLICY_POLICY_TYPES_H_ diff --git a/src/components/include/policy/policy_regular/policy/usage_statistics/statistics_manager.h b/src/components/include/policy/policy_regular/policy/usage_statistics/statistics_manager.h new file mode 100644 index 0000000000..2b2c875d11 --- /dev/null +++ b/src/components/include/policy/policy_regular/policy/usage_statistics/statistics_manager.h @@ -0,0 +1,79 @@ +/* + * 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_INCLUDE_POLICY_USAGE_STATISTICS_STATISTICS_MANAGER_H_ +#define SRC_COMPONENTS_INCLUDE_POLICY_USAGE_STATISTICS_STATISTICS_MANAGER_H_ + +#include <stdint.h> +#include <string> + +namespace usage_statistics { + +enum GlobalCounterId { IAP_BUFFER_FULL, SYNC_OUT_OF_MEMORY, SYNC_REBOOTS }; + +enum AppInfoId { LANGUAGE_GUI, LANGUAGE_VUI }; + +enum AppStopwatchId { + SECONDS_HMI_FULL, + SECONDS_HMI_LIMITED, + SECONDS_HMI_BACKGROUND, + SECONDS_HMI_NONE +}; + +enum AppCounterId { + USER_SELECTIONS, + REJECTIONS_SYNC_OUT_OF_MEMORY, + REJECTIONS_NICKNAME_MISMATCH, + REJECTIONS_DUPLICATE_NAME, + REJECTED_RPC_CALLS, + RPCS_IN_HMI_NONE, + REMOVALS_MISBEHAVED, + RUN_ATTEMPTS_WHILE_REVOKED, + COUNT_OF_TLS_ERRORS, +}; + +class StatisticsManager { + public: + virtual ~StatisticsManager() {} + virtual void Increment(GlobalCounterId type) = 0; + virtual void Increment(const std::string& app_id, AppCounterId type) = 0; + virtual void Set(const std::string& app_id, + AppInfoId type, + const std::string& value) = 0; + virtual void Add(const std::string& app_id, + AppStopwatchId type, + int32_t timespan_seconds) = 0; +}; + +} // namespace usage_statistics + +#endif // SRC_COMPONENTS_INCLUDE_POLICY_USAGE_STATISTICS_STATISTICS_MANAGER_H_ diff --git a/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h b/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h new file mode 100644 index 0000000000..0f348d14e2 --- /dev/null +++ b/src/components/include/test/policy/policy_regular/policy/mock_policy_manager.h @@ -0,0 +1,187 @@ +/* + * 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_INCLUDE_TEST_POLICY_MOCK_POLICY_MANAGER_H_ +#define SRC_COMPONENTS_INCLUDE_TEST_POLICY_MOCK_POLICY_MANAGER_H_ + +#include <string> +#include <vector> +#include "gmock/gmock.h" +#include "policy/policy_listener.h" +#include "policy/policy_types.h" +#include "policy/usage_statistics/statistics_manager.h" + +#include "rpc_base/rpc_base.h" +#include "policy/policy_manager.h" + +namespace policy_table = ::rpc::policy_table_interface_base; + +using namespace policy; + +namespace test { +namespace components { +namespace policy_manager_test { + +class MockPolicyManager : public PolicyManager { + public: + MOCK_METHOD1(set_listener, void(PolicyListener* listener)); + MOCK_METHOD2(InitPT, + bool(const std::string& file_name, + const PolicySettings* settings)); + MOCK_METHOD2(LoadPT, + bool(const std::string& file, const BinaryMessage& pt_content)); + MOCK_METHOD1(ResetPT, bool(const std::string& file_name)); + + MOCK_METHOD2(GetUpdateUrls, + void(const uint32_t service_type, EndpointUrls& out_end_points)); + MOCK_METHOD2(GetUpdateUrls, + void(const std::string& service_type, + EndpointUrls& out_end_points)); + MOCK_METHOD0(RequestPTUpdate, bool()); + MOCK_METHOD5(CheckPermissions, + void(const PTString& app_id, + const PTString& hmi_level, + const PTString& rpc, + const RPCParams& rpc_params, + CheckPermissionResult& result)); + MOCK_METHOD0(ResetUserConsent, bool()); + MOCK_CONST_METHOD0(GetPolicyTableStatus, std::string()); + MOCK_METHOD1(KmsChanged, void(int kilometers)); + MOCK_METHOD0(IncrementIgnitionCycles, void()); + MOCK_METHOD0(ForcePTExchange, std::string()); + MOCK_METHOD0(ResetRetrySequence, void()); + MOCK_METHOD0(NextRetryTimeout, uint32_t()); + MOCK_METHOD0(TimeoutExchange, int()); + MOCK_METHOD0(RetrySequenceDelaysSeconds, const std::vector<int>()); + MOCK_METHOD0(OnExceededTimeout, void()); + MOCK_METHOD0(OnUpdateStarted, void()); + MOCK_CONST_METHOD1(GetUserConsentForDevice, + DeviceConsent(const std::string& device_id)); + MOCK_METHOD3( + GetUserConsentForApp, + void(const std::string& device_id, + const std::string& policy_app_id, + std::vector<policy::FunctionalGroupPermission>& permissions)); + MOCK_METHOD2(SetUserConsentForDevice, + void(const std::string& device_id, const bool is_allowed)); + MOCK_METHOD2(ReactOnUserDevConsentForApp, + bool(const std::string app_id, bool is_device_allowed)); + MOCK_METHOD2(PTUpdatedAt, void(policy::Counters counter, int value)); + + MOCK_METHOD3(GetInitialAppData, + bool(const std::string&, + policy::StringArray*, + policy::StringArray*)); + + MOCK_METHOD2(AddDevice, + void(const std::string& device_id, + const std::string& connection_type)); + MOCK_METHOD2(SetDeviceInfo, + void(const std::string& device_id, + const policy::DeviceInfo& device_info)); + MOCK_METHOD1(SetUserConsentForApp, + void(const policy::PermissionConsent& permissions)); + MOCK_CONST_METHOD2(GetDefaultHmi, + bool(const std::string& policy_app_id, + std::string* default_hmi)); + MOCK_CONST_METHOD2(GetPriority, + bool(const std::string& policy_app_id, + std::string* priority)); + MOCK_METHOD2(GetUserFriendlyMessages, + std::vector<policy::UserFriendlyMessage>( + const std::vector<std::string>& message_code, + const std::string& language)); + MOCK_CONST_METHOD1(IsApplicationRevoked, bool(const std::string& app_id)); + MOCK_METHOD3( + GetPermissionsForApp, + void(const std::string& device_id, + const std::string& policy_app_id, + std::vector<policy::FunctionalGroupPermission>& permissions)); + MOCK_METHOD1(GetAppPermissionsChanges, + policy::AppPermissions(const std::string& policy_app_id)); + MOCK_METHOD1(RemovePendingPermissionChanges, void(const std::string& app_id)); + MOCK_CONST_METHOD1(GetCurrentDeviceId, + std::string&(const std::string& policy_app_id)); + MOCK_METHOD1(SetSystemLanguage, void(const std::string& language)); + MOCK_METHOD3(SetSystemInfo, + void(const std::string& ccpu_version, + const std::string& wers_country_code, + const std::string& language)); + MOCK_METHOD1(SendNotificationOnPermissionsUpdated, + void(const std::string& application_id)); + MOCK_METHOD1(MarkUnpairedDevice, void(const std::string& device_id)); + MOCK_METHOD1(AddApplication, void(const std::string& application_id)); + MOCK_METHOD0(CleanupUnpairedDevices, bool()); + MOCK_CONST_METHOD1(CanAppKeepContext, bool(const std::string& app_id)); + MOCK_CONST_METHOD1(CanAppStealFocus, bool(const std::string& app_id)); + MOCK_METHOD0(OnSystemReady, void()); + MOCK_CONST_METHOD1(GetNotificationsNumber, + uint32_t(const std::string& priority)); + MOCK_METHOD1(SetVINValue, void(const std::string& value)); + MOCK_METHOD1(IsPredataPolicy, bool(const std::string& policy_app_id)); + MOCK_CONST_METHOD1(HeartBeatTimeout, uint32_t(const std::string& app_id)); + MOCK_METHOD1(SaveUpdateStatusRequired, void(bool is_update_needed)); + MOCK_METHOD0(OnAppsSearchStarted, void()); + MOCK_METHOD0(OnAppsSearchCompleted, void()); + MOCK_METHOD1(OnAppRegisteredOnMobile, + void(const std::string& application_id)); + MOCK_CONST_METHOD1( + GetAppRequestTypes, + const std::vector<std::string>(const std::string policy_app_id)); + MOCK_CONST_METHOD0(GetVehicleInfo, const policy::VehicleInfo()); + MOCK_CONST_METHOD0(GetMetaInfo, const policy::MetaInfo()); + MOCK_CONST_METHOD0(RetrieveCertificate, std::string()); + MOCK_METHOD1(SetDecryptedCertificate, void(const std::string&)); + MOCK_METHOD0(ExceededIgnitionCycles, bool()); + MOCK_METHOD0(ExceededDays, bool()); + MOCK_METHOD0(StartPTExchange, void()); + MOCK_METHOD1(Increment, void(usage_statistics::GlobalCounterId type)); + MOCK_METHOD2(Increment, + void(const std::string& app_id, + usage_statistics::AppCounterId type)); + MOCK_METHOD3(Set, + void(const std::string& app_id, + usage_statistics::AppInfoId type, + const std::string& value)); + MOCK_METHOD3(Add, + void(const std::string& app_id, + usage_statistics::AppStopwatchId type, + int32_t timespan_seconds)); + MOCK_CONST_METHOD0(get_settings, const PolicySettings&()); + MOCK_METHOD1(set_settings, void(const PolicySettings* get_settings)); + MOCK_CONST_METHOD0(GetLockScreenIconUrl, std::string()); +}; +} // namespace policy_manager_test +} // namespace components +} // namespace test + +#endif // SRC_COMPONENTS_INCLUDE_TEST_POLICY_MOCK_POLICY_MANAGER_H_ diff --git a/src/components/include/test/policy/policy_regular/policy/mock_policy_settings.h b/src/components/include/test/policy/policy_regular/policy/mock_policy_settings.h new file mode 100644 index 0000000000..438e697c51 --- /dev/null +++ b/src/components/include/test/policy/policy_regular/policy/mock_policy_settings.h @@ -0,0 +1,58 @@ +/* + * 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_INCLUDE_TEST_POLICY_MOCK_POLICY_SETTINGS_H_ +#define SRC_COMPONENTS_INCLUDE_TEST_POLICY_MOCK_POLICY_SETTINGS_H_ + +#include "gmock/gmock.h" +#include <string> +#include "policy/policy_settings.h" + +namespace test { +namespace components { +namespace policy_handler_test { + +class MockPolicySettings : public ::policy::PolicySettings { + public: + MOCK_CONST_METHOD0(enable_policy, bool()); + MOCK_CONST_METHOD0(preloaded_pt_file, const std::string&()); + MOCK_CONST_METHOD0(app_storage_folder, const std::string&()); + MOCK_CONST_METHOD0(attempts_to_open_policy_db, uint16_t()); + MOCK_CONST_METHOD0(open_attempt_timeout_ms, uint16_t()); + MOCK_CONST_METHOD0(policies_snapshot_file_name, const std::string&()); + MOCK_CONST_METHOD0(system_files_path, const std::string&()); +}; + +} // namespace policy_test +} // namespace components +} // namespace test + +#endif // SRC_COMPONENTS_INCLUDE_TEST_POLICY_MOCK_POLICY_SETTINGS_H_ diff --git a/src/components/include/test/policy/policy_regular/policy/usage_statistics/mock_app_stopwatch.h b/src/components/include/test/policy/policy_regular/policy/usage_statistics/mock_app_stopwatch.h new file mode 100644 index 0000000000..481d887cb2 --- /dev/null +++ b/src/components/include/test/policy/policy_regular/policy/usage_statistics/mock_app_stopwatch.h @@ -0,0 +1,54 @@ +/* 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_INCLUDE_TEST_POLICY_USAGE_STATISTICS_MOCK_APP_STOPWATCH_H_ +#define SRC_COMPONENTS_INCLUDE_TEST_POLICY_USAGE_STATISTICS_MOCK_APP_STOPWATCH_H_ + +#include "gmock/gmock.h" +#include "policy/usage_statistics/app_stopwatch.h" +#include "policy/usage_statistics/statistics_manager.h" + +namespace test { +namespace components { +namespace usage_statistics_test { + +class MockAppStopwatch : public usage_statistics::AppStopwatch { + public: + MOCK_METHOD1(Start, void(usage_statistics::AppStopwatchId stopwatch_type)); + MOCK_METHOD1(Switch, void(usage_statistics::AppStopwatchId stopwatch_type)); + MOCK_METHOD0(WriteTime, void()); +}; + +} // namespace usage_statistics_test +} // namespace components +} // namespace test + +#endif // SRC_COMPONENTS_INCLUDE_TEST_POLICY_USAGE_STATISTICS_MOCK_APP_STOPWATCH_H_ diff --git a/src/components/include/test/policy/policy_regular/policy/usage_statistics/mock_statistics_manager.h b/src/components/include/test/policy/policy_regular/policy/usage_statistics/mock_statistics_manager.h new file mode 100644 index 0000000000..e58adea124 --- /dev/null +++ b/src/components/include/test/policy/policy_regular/policy/usage_statistics/mock_statistics_manager.h @@ -0,0 +1,63 @@ +/* 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_INCLUDE_TEST_POLICY_USAGE_STATISTICS_MOCK_STATISTICS_MANAGER_H_ +#define SRC_COMPONENTS_INCLUDE_TEST_POLICY_USAGE_STATISTICS_MOCK_STATISTICS_MANAGER_H_ + +#include <string> + +#include "gmock/gmock.h" +#include "policy/usage_statistics/statistics_manager.h" + +namespace test { +namespace components { +namespace usage_statistics_test { + +class MockStatisticsManager : public usage_statistics::StatisticsManager { + public: + MOCK_METHOD1(Increment, void(usage_statistics::GlobalCounterId type)); + MOCK_METHOD2(Increment, + void(const std::string& app_id, + usage_statistics::AppCounterId type)); + MOCK_METHOD3(Set, + void(const std::string& app_id, + usage_statistics::AppInfoId type, + const std::string& value)); + MOCK_METHOD3(Add, + void(const std::string& app_id, + usage_statistics::AppStopwatchId type, + int32_t timespan_seconds)); +}; + +} // namespace usage_statistics_test +} // namespace components +} // namespace test + +#endif // SRC_COMPONENTS_INCLUDE_TEST_POLICY_USAGE_STATISTICS_MOCK_STATISTICS_MANAGER_H_ |