From c3466b57c8c783f0919101f9d350870a14859b02 Mon Sep 17 00:00:00 2001 From: Alexander Date: Fri, 20 Jul 2018 13:06:09 +0300 Subject: Add Interior data cache and interior data manager Add helpers functions for RC --- .../include/rc_rpc_plugin/interior_data_cache.h | 81 +++++++++++ .../rc_rpc_plugin/interior_data_cache_impl.h | 64 +++++++++ .../include/rc_rpc_plugin/interior_data_manager.h | 86 +++++++++++ .../rc_rpc_plugin/interior_data_manager_impl.h | 122 ++++++++++++++++ .../include/rc_rpc_plugin/rc_helpers.h | 82 +++++++++++ .../rc_rpc_plugin/src/interior_data_cache_impl.cc | 121 ++++++++++++++++ .../src/interior_data_manager_impl.cc | 159 ++++++++++++++++++++ .../rpc_plugins/rc_rpc_plugin/src/rc_helpers.cc | 88 ++++++++++++ .../rc_rpc_plugin/mock/mock_interior_data_cache.h | 54 +++++++ .../mock/mock_interior_data_manager.h | 55 +++++++ .../rc_rpc_plugin/test/interior_data_cache_test.cc | 160 +++++++++++++++++++++ 11 files changed, 1072 insertions(+) create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache_impl.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_helpers.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_cache_impl.cc create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_helpers.cc create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_cache.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_manager.h create mode 100644 src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/interior_data_cache_test.cc (limited to 'src/components/application_manager/rpc_plugins') diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache.h new file mode 100644 index 0000000000..f12566d14c --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_CACHE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_CACHE_H_ +#include +#include "smart_objects/smart_object.h" + +namespace rc_rpc_plugin { + +/** + * @brief The InteriorDataCache interface for caching data class + * Provide ability to cache module data by module type name and clear cache + */ +class InteriorDataCache { + public: + /** + * @brief Add module data to cache + * @param module_type module type name + * @param module_data data to be cached + */ + virtual void Add(const std::string& module_type, + const smart_objects::SmartObject& module_data) = 0; + + /** + * @brief Retrieve Get cached data + * @param module_type data type to get from cache + * @return smart object with cached data, or nulll smart object + */ + virtual smart_objects::SmartObject Retrieve( + const std::string& module_type) const = 0; + + /** + * @brief Contains check if data exists in cache + * @param module_type module type name to check in cache + * @return true if cached, false otherwize + */ + virtual bool Contains(const std::string& module_type) const = 0; + + /** + * @brief Remove cached data + * @param module_type data type to remove from cache + */ + virtual void Remove(const std::string& module_type) = 0; + + /** + * @brief Clear clear all cached data + */ + virtual void Clear() = 0; +}; +} // rc_rpc_plugin + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_CACHE_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache_impl.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache_impl.h new file mode 100644 index 0000000000..f2971e3d72 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_cache_impl.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_CACHE_IMPL_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_CACHE_IMPL_H_ + +#include + +#include "utils/macro.h" +#include "utils/lock.h" +#include "rc_rpc_plugin/interior_data_cache.h" + +namespace rc_rpc_plugin { +class InteriorDataCacheImpl : public InteriorDataCache { + public: + InteriorDataCacheImpl(); + + ~InteriorDataCacheImpl(); + + void Add(const std::string& module_type, + const smart_objects::SmartObject& module_data) OVERRIDE; + smart_objects::SmartObject Retrieve( + const std::string& module_type) const OVERRIDE; + bool Contains(const std::string& module_type) const OVERRIDE; + void Remove(const std::string& module_type) OVERRIDE; + void Clear() OVERRIDE; + + private: + std::map cached_data_; + mutable sync_primitives::Lock cached_data_lock_; +}; + +} // rc_rpc_plugin + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_CACHE_IMPL_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager.h new file mode 100644 index 0000000000..f28c388055 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager.h @@ -0,0 +1,86 @@ +/* + Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_MANAGER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_MANAGER_H_ + +#include "application_manager/application.h" +#include "application_manager/plugin_manager/rpc_plugin.h" + +namespace rc_rpc_plugin { + +namespace app_mngr = application_manager; +namespace plugins = application_manager::plugin_manager; + +class InteriorDataManager { + public: + /** + * @brief OnPolicyEvent Processes policy related events + * @param event Policy event + */ + virtual void OnPolicyEvent(app_mngr::plugin_manager::PolicyEvent event) = 0; + + /** + * @brief OnApplicationEvent Notifies modules on certain application events + * @param event Event + * @param application Pointer to application struct + */ + virtual void OnApplicationEvent( + plugins::ApplicationEvent event, + app_mngr::ApplicationSharedPtr application) = 0; + + /** + * @brief OnDisablingRC process disable RC event. Unsubscribe from all modules + * and clear cache + */ + virtual void OnDisablingRC() = 0; + + /** + * @brief StoreRequestToHMITime save information and time stamp of + * current interior data subscriptions + */ + virtual void StoreRequestToHMITime(const std::string& module_type) = 0; + + /** + * @brief CheckRequestsToHMIFrequency check that rate limits are not allowed of + * bounce during current time frame. + * calculate amount of requests per module type in time frame and checks if it + * bigger then allowed by ini file + * @param module_type moduletype to calculate frequency on + * @return true if amount of requests was not exceeded, otherwise return false. + */ + virtual bool CheckRequestsToHMIFrequency(const std::string& module_type) = 0; +}; + +} // namespace rc_rpc_plugin + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_MANAGER_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h new file mode 100644 index 0000000000..b36f47f260 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/interior_data_manager_impl.h @@ -0,0 +1,122 @@ +/* + Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_MANAGER_IMPL_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_MANAGER_IMPL_H_ +#include "rc_rpc_plugin/interior_data_manager.h" +#include "utils/date_time.h" + +namespace application_manager { +class ApplicationManager; +namespace rpc_service { +class RPCService; +} +} +namespace rc_rpc_plugin { + +class InteriorDataCache; +class RCRPCPlugin; + +class InteriorDataManagerImpl : public InteriorDataManager { + public: + InteriorDataManagerImpl( + RCRPCPlugin& rc_plugin, + InteriorDataCache& cache, + application_manager::ApplicationManager& app_mngr, + application_manager::rpc_service::RPCService& rpc_service); + + void OnPolicyEvent(app_mngr::plugin_manager::PolicyEvent event) OVERRIDE; + + void OnApplicationEvent(plugins::ApplicationEvent event, + app_mngr::ApplicationSharedPtr application) OVERRIDE; + + void OnDisablingRC() OVERRIDE; + + void StoreRequestToHMITime(const std::string& module_type) OVERRIDE; + + bool CheckRequestsToHMIFrequency(const std::string& module_type) OVERRIDE; + + private: + /** + * @brief UpdateHMISubscriptionsOnPolicyUpdated process policy update event. + * If some modules was disabeled by policies and there are no applications + * that subscribed to them - send RC.GetInteriorVehicleData(subscribe=false) + * and clear cache + */ + void UpdateHMISubscriptionsOnPolicyUpdated(); + + /** + * @brief UpdateHMISubscriptionsOnAppUnregistered process AppUnregistered + * event and unsubscribed from not actual module types + * @param app application that was unregistered + */ + void UpdateHMISubscriptionsOnAppUnregistered( + application_manager::Application& app); + + /** + * @brief UnsubscribeFromInteriorVehicleData remove module_type from cache and + * send RC.GetInteriorVehicleData(subscribe=false) to HMI + * @param module_type module type that need to be unsubscribed + */ + void UnsubscribeFromInteriorVehicleData(const std::string& module_type); + + void ClearOldRequestsToHMIHistory(); + /** + * @brief AppsModules mapping from applications to list of modules + */ + typedef std::map > AppsModules; + + /** + * @brief AppsSubscribedModules get mapping of application to list of + * subscribed modules + * @return map of applications to list of subscribed modules + */ + AppsModules AppsSubscribedModules(); + + /** + * @brief RequestsToHMIHistory mapping from module type to vector of time + * stamps + */ + typedef std::map > + RequestsToHMIHistory; + RequestsToHMIHistory requests_to_hmi_history_; + mutable sync_primitives::Lock requests_to_hmi_history_lock_; + + RCRPCPlugin& rc_plugin_; + InteriorDataCache& cache_; + application_manager::ApplicationManager& app_mngr_; + application_manager::rpc_service::RPCService& rpc_service_; +}; + +} // namespace rc_rpc_plugin +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_INTERIOR_DATA_MANAGER_IMPL_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_helpers.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_helpers.h new file mode 100644 index 0000000000..e20a982d91 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_helpers.h @@ -0,0 +1,82 @@ +/* + Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_HELPERS_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_HELPERS_H_ + +#include +#include +#include "application_manager/application.h" +#include "rc_rpc_plugin/rc_app_extension.h" + +namespace rc_rpc_plugin { +class RCRPCPlugin; + +/** + * @brief The RCHelpers class contains frequently used static data + * structures related strictly to RC + * Converters, mapping, factory functions + */ +class RCHelpers { + public: + /** + * @brief GetModuleTypeToDataMapping get mapping of module type enum naming to + * actual module data filed name + * @return module mapping from enum naming to filed name + */ + static const std::function + GetModuleTypeToDataMapping(); + + /** + * @brief GetRCExtension extract RC extension from application + * @param app application to extract extension + * @return rc extension of app is rc applicaiton, otherwise return emty shared + * pointer. + */ + static RCAppExtensionPtr GetRCExtension( + application_manager::Application& app); + + static smart_objects::SmartObjectSPtr CreateUnsubscribeRequestToHMI( + const std::string& module_type, const uint32_t correlation_id); + + static std::vector + AppsSubscribedToModuleType(application_manager::ApplicationManager& app_mngr, + const std::string& module_type); + + typedef std::map > AppsModules; + static AppsModules GetApplicaitonsAllowedModules( + application_manager::ApplicationManager& app_mngr); +}; + +} // rc_rpc_plugin +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_HELPERS_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_cache_impl.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_cache_impl.cc new file mode 100644 index 0000000000..0eb175aa25 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_cache_impl.cc @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2018, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include "rc_rpc_plugin/interior_data_cache_impl.h" +#include "utils/date_time.h" +#include "utils/logger.h" + +namespace rc_rpc_plugin { + +CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule"); + +InteriorDataCacheImpl::InteriorDataCacheImpl() {} + +InteriorDataCacheImpl::~InteriorDataCacheImpl() {} + +/** + * @brief MergeModuleData key all keys and values from first parameter and + * update and append keys and values from the second + * @param data1 - initial data + * @param data2 - updated data + * @return updated data1 with data2 keys and values + */ +smart_objects::SmartObject MergeModuleData( + const smart_objects::SmartObject& data1, + const smart_objects::SmartObject& data2) { + smart_objects::SmartObject result = data1; + auto it = data2.map_begin(); + for (; it != data2.map_end(); ++it) { + const std::string& key = it->first; + const smart_objects::SmartObject& value = it->second; + result[key] = value; + } + return result; +} + +void InteriorDataCacheImpl::Add(const std::string& module_type, + const smart_objects::SmartObject& module_data) { + LOG4CXX_TRACE(logger_, "module_type : " << module_type); + sync_primitives::AutoLock autolock(cached_data_lock_); + auto it = cached_data_.find(module_type); + if (cached_data_.end() == it) { + cached_data_[module_type] = module_data; + return; + } + cached_data_[module_type] = MergeModuleData(it->second, module_data); +} + +smart_objects::SmartObject InteriorDataCacheImpl::Retrieve( + const std::string& module_type) const { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock autolock(cached_data_lock_); + auto it = cached_data_.find(module_type); + if (it == cached_data_.end()) { + LOG4CXX_WARN(logger_, + "Module type " << module_type << " was not found in cache"); + return smart_objects::SmartObject(smart_objects::SmartType_Null); + } + LOG4CXX_TRACE(logger_, "module_type : " << module_type); + return it->second; +} + +bool InteriorDataCacheImpl::Contains(const std::string& module_type) const { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock autolock(cached_data_lock_); + auto it = cached_data_.find(module_type); + const bool contains = it != cached_data_.end(); + LOG4CXX_TRACE(logger_, + "module_type : " << module_type << " " + << (contains ? "true" : "false")); + return contains; +} + +void InteriorDataCacheImpl::Remove(const std::string& module_type) { + LOG4CXX_TRACE(logger_, "module_type : " << module_type); + sync_primitives::AutoLock autolock(cached_data_lock_); + auto it = cached_data_.find(module_type); + if (cached_data_.end() == it) { + LOG4CXX_TRACE(logger_, "Not existing module_type : " << module_type); + return; + } + cached_data_.erase(it); +} + +void InteriorDataCacheImpl::Clear() { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock autolock(cached_data_lock_); + cached_data_.clear(); +} +} diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc new file mode 100644 index 0000000000..1f6290ad10 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/interior_data_manager_impl.cc @@ -0,0 +1,159 @@ +#include "rc_rpc_plugin/interior_data_manager_impl.h" +#include "rc_rpc_plugin/rc_helpers.h" +#include "rc_rpc_plugin/rc_rpc_plugin.h" +#include "application_manager/application_manager.h" +#include "application_manager/rpc_service.h" + +namespace rc_rpc_plugin { +CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule"); + +InteriorDataManagerImpl::InteriorDataManagerImpl( + RCRPCPlugin& rc_plugin, + InteriorDataCache& cache, + application_manager::ApplicationManager& app_mngr, + application_manager::rpc_service::RPCService& rpc_service) + : rc_plugin_(rc_plugin) + , cache_(cache) + , app_mngr_(app_mngr) + , rpc_service_(rpc_service) {} + +void InteriorDataManagerImpl::OnPolicyEvent(plugins::PolicyEvent event) { + UpdateHMISubscriptionsOnPolicyUpdated(); +} + +void InteriorDataManagerImpl::OnApplicationEvent( + plugins::ApplicationEvent event, + app_mngr::ApplicationSharedPtr application) { + if (plugins::ApplicationEvent::kApplicationUnregistered == event || + plugins::ApplicationEvent::kApplicationExit == event) { + UpdateHMISubscriptionsOnAppUnregistered(*application); + } +} + +void InteriorDataManagerImpl::OnDisablingRC() { + LOG4CXX_AUTO_TRACE(logger_); + auto existing_subscription = AppsSubscribedModules(); + std::set subscribed_modules; + for (auto& pair : existing_subscription) { + auto& app = pair.first; + auto rc_extension = RCHelpers::GetRCExtension(*app); + for (const auto& module : pair.second) { + subscribed_modules.insert(module); + rc_extension->UnsubscribeFromInteriorVehicleData(module); + } + } + for (auto& module : subscribed_modules) { + LOG4CXX_TRACE(logger_, "unsubscribe " << module); + UnsubscribeFromInteriorVehicleData(module); + } +} + +void InteriorDataManagerImpl::StoreRequestToHMITime( + const std::string& module_type) { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock autolock(requests_to_hmi_history_lock_); + requests_to_hmi_history_[module_type].push_back( + date_time::DateTime::getCurrentTime()); +} + +bool InteriorDataManagerImpl::CheckRequestsToHMIFrequency( + const std::string& module_type) { + LOG4CXX_AUTO_TRACE(logger_); + sync_primitives::AutoLock autolock(requests_to_hmi_history_lock_); + ClearOldRequestsToHMIHistory(); + const auto& history = requests_to_hmi_history_[module_type]; + const auto limit = + app_mngr_.get_settings().get_interior_vehicle_data_frequency().first; + return history.size() < limit; +} + +void InteriorDataManagerImpl::UpdateHMISubscriptionsOnPolicyUpdated() { + auto apps_allowed_modules = + RCHelpers::GetApplicaitonsAllowedModules(app_mngr_); + auto apps_subscribed_modules = AppsSubscribedModules(); + InteriorDataManagerImpl::AppsModules apps_disallowed_modules; + for (auto& pair : apps_subscribed_modules) { + auto& allowed = apps_allowed_modules[pair.first]; + auto& subscribed = pair.second; + std::vector disallowed_modules; + std::set_difference(subscribed.begin(), + subscribed.end(), + allowed.begin(), + allowed.end(), + std::back_inserter(disallowed_modules)); + apps_disallowed_modules[pair.first] = disallowed_modules; + } + + for (auto& pair : apps_disallowed_modules) { + auto& app = pair.first; + auto rc_extension = RCHelpers::GetRCExtension(*app); + for (const auto& module : pair.second) { + rc_extension->UnsubscribeFromInteriorVehicleData(module); + auto apps_subscribed = + RCHelpers::AppsSubscribedToModuleType(app_mngr_, module); + if (apps_subscribed.empty()) { + UnsubscribeFromInteriorVehicleData(module); + } + } + } +} + +void InteriorDataManagerImpl::UpdateHMISubscriptionsOnAppUnregistered( + application_manager::Application& app) { + LOG4CXX_AUTO_TRACE(logger_); + auto rc_extension = RCHelpers::GetRCExtension(app); + auto subscribed_data = rc_extension->InteriorVehicleDataSubscriptions(); + rc_extension->UnsubscribeFromInteriorVehicleData(); + for (auto& data : subscribed_data) { + auto apps_subscribed = + RCHelpers::AppsSubscribedToModuleType(app_mngr_, data); + if (apps_subscribed.empty()) { + UnsubscribeFromInteriorVehicleData(data); + } + if (apps_subscribed.size() == 1 && + apps_subscribed.front()->hmi_app_id() == app.hmi_app_id()) { + UnsubscribeFromInteriorVehicleData(data); + } + } +} + +void InteriorDataManagerImpl::UnsubscribeFromInteriorVehicleData( + const std::string& module_type) { + cache_.Remove(module_type); + auto unsubscribe_request = RCHelpers::CreateUnsubscribeRequestToHMI( + module_type, app_mngr_.GetNextHMICorrelationID()); + LOG4CXX_DEBUG(logger_, "Send Unsubscribe from " << module_type); + rpc_service_.ManageHMICommand(unsubscribe_request); +} + +void InteriorDataManagerImpl::ClearOldRequestsToHMIHistory() { + auto limit = + app_mngr_.get_settings().get_interior_vehicle_data_frequency().second; + uint32_t time_frame = limit * date_time::DateTime::MILLISECONDS_IN_SECOND; + auto lest_that_time_frame_ago = [time_frame](TimevalStruct time) { + auto span = date_time::DateTime::calculateTimeSpan(time); + return span < time_frame; + }; + for (auto& it : requests_to_hmi_history_) { + auto& history = it.second; + auto first_actual = + std::find_if(history.begin(), history.end(), lest_that_time_frame_ago); + history.erase(history.begin(), first_actual); + } +} + +InteriorDataManagerImpl::AppsModules +InteriorDataManagerImpl::AppsSubscribedModules() { + auto apps_list = RCRPCPlugin::GetRCApplications(app_mngr_); + InteriorDataManagerImpl::AppsModules result; + for (auto& app_ptr : apps_list) { + const auto rc_extension = RCHelpers::GetRCExtension(*app_ptr); + auto app_subscriptions = rc_extension->InteriorVehicleDataSubscriptions(); + result[app_ptr] = std::vector(app_subscriptions.size()); + std::copy(app_subscriptions.begin(), + app_subscriptions.end(), + result[app_ptr].begin()); + } + return result; +} +} // namespace rc_rpc_plugin diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_helpers.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_helpers.cc new file mode 100644 index 0000000000..a8c29752d7 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_helpers.cc @@ -0,0 +1,88 @@ +#include "rc_rpc_plugin/rc_helpers.h" +#include "rc_rpc_plugin/rc_module_constants.h" +#include "rc_rpc_plugin/rc_rpc_plugin.h" +#include "application_manager/smart_object_keys.h" +#include "application_manager/commands/command_impl.h" +#include "application_manager/message.h" + +namespace rc_rpc_plugin { +CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule"); + +const std::function +RCHelpers::GetModuleTypeToDataMapping() { + auto mapping_lambda = [](const std::string& module_type) -> std::string { + static std::map mapping = { + {enums_value::kRadio, message_params::kRadioControlData}, + {enums_value::kClimate, message_params::kClimateControlData}, + {enums_value::kSeat, message_params::kSeatControlData}}; + auto it = mapping.find(module_type); + if (mapping.end() == it) { + return std::string(); + } + return it->second; + }; + + return mapping_lambda; +} + +RCAppExtensionPtr RCHelpers::GetRCExtension( + application_manager::Application& app) { + auto extension_interface = app.QueryInterface(RCRPCPlugin::kRCPluginID); + auto extension = + std::static_pointer_cast(extension_interface); + return extension; +} + +smart_objects::SmartObjectSPtr RCHelpers::CreateUnsubscribeRequestToHMI( + const std::string& module_type, const uint32_t correlation_id) { + using namespace smart_objects; + namespace commands = application_manager::commands; + namespace am_strings = application_manager::strings; + + SmartObjectSPtr message = std::make_shared(SmartType_Map); + SmartObject& params = (*message)[am_strings::params]; + SmartObject& msg_params = (*message)[am_strings::msg_params]; + + params[am_strings::message_type] = + static_cast(application_manager::kRequest); + params[am_strings::protocol_version] = + commands::CommandImpl::protocol_version_; + params[am_strings::protocol_type] = commands::CommandImpl::hmi_protocol_type_; + params[am_strings::correlation_id] = correlation_id; + params[am_strings::function_id] = + hmi_apis::FunctionID::RC_GetInteriorVehicleData; + msg_params[message_params::kSubscribe] = false; + msg_params[message_params::kModuleType] = module_type; + return message; +} + +std::vector +RCHelpers::AppsSubscribedToModuleType( + application_manager::ApplicationManager& app_mngr, + const std::string& module_type) { + std::vector result; + auto rc_apps = RCRPCPlugin::GetRCApplications(app_mngr); + for (auto& app : rc_apps) { + auto rc_ext = RCHelpers::GetRCExtension(*app); + DCHECK_OR_RETURN(rc_ext, result); + if (rc_ext->IsSubscibedToInteriorVehicleData(module_type)) { + result.push_back(app); + } + } + return result; +} + +RCHelpers::AppsModules RCHelpers::GetApplicaitonsAllowedModules( + app_mngr::ApplicationManager& app_mngr) { + auto apps_list = RCRPCPlugin::GetRCApplications(app_mngr); + RCHelpers::AppsModules result; + for (auto& app_ptr : apps_list) { + std::vector allowed_modules; + app_mngr.GetPolicyHandler().GetModuleTypes(app_ptr->policy_app_id(), + &allowed_modules); + std::sort(allowed_modules.begin(), allowed_modules.end()); + result[app_ptr] = allowed_modules; + } + return result; +} +} diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_cache.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_cache.h new file mode 100644 index 0000000000..45465f96b0 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_cache.h @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_TEST_INCLUDE_RC_RPC_PLUGIN_MOCK_MOCK_INTERIOR_DATA_CACHE_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_TEST_INCLUDE_RC_RPC_PLUGIN_MOCK_MOCK_INTERIOR_DATA_CACHE_H_ + +#include +#include "gmock/gmock.h" +#include "rc_rpc_plugin/interior_data_cache.h" + +namespace rc_rpc_plugin_test { + +class MockInteriorDataCache : public rc_rpc_plugin::InteriorDataCache { + public: + MOCK_METHOD2(Add, + void(const std::string&, const smart_objects::SmartObject&)); + MOCK_CONST_METHOD1(Retrieve, smart_objects::SmartObject(const std::string&)); + MOCK_CONST_METHOD1(Contains, bool(const std::string&)); + MOCK_METHOD1(Remove, void(const std::string&)); + MOCK_METHOD0(Clear, void()); +}; + +} // namespace rc_rpc_plugin_test + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_TEST_INCLUDE_RC_RPC_PLUGIN_MOCK_MOCK_INTERIOR_DATA_CACHE_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_manager.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_manager.h new file mode 100644 index 0000000000..fc19c6a889 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_interior_data_manager.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2018, 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_RPC_PLUGINS_RC_RPC_PLUGIN_TEST_INCLUDE_RC_RPC_PLUGIN_MOCK_MOCK_INTERIOR_DATA_MANAGER_H_ +#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_TEST_INCLUDE_RC_RPC_PLUGIN_MOCK_MOCK_INTERIOR_DATA_MANAGER_H_ + +#include +#include "gmock/gmock.h" +#include "rc_rpc_plugin/interior_data_manager.h" +namespace rc_rpc_plugin_test { + +class MockInteriorDataManager : public rc_rpc_plugin::InteriorDataManager { + public: + MOCK_METHOD1(OnPolicyEvent, + void(application_manager::plugin_manager::PolicyEvent)); + MOCK_METHOD2(OnApplicationEvent, + void(application_manager::plugin_manager::ApplicationEvent, + application_manager::ApplicationSharedPtr)); + MOCK_METHOD0(OnDisablingRC, void()); + MOCK_METHOD1(StoreRequestToHMITime, void(const std::string&)); + MOCK_METHOD1(CheckRequestsToHMIFrequency, bool(const std::string&)); +}; + +} // namespace rc_rpc_plugin_test + +#endif // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_TEST_INCLUDE_RC_RPC_PLUGIN_MOCK_MOCK_INTERIOR_DATA_MANAGER_H_ diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/interior_data_cache_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/interior_data_cache_test.cc new file mode 100644 index 0000000000..e6922a4c83 --- /dev/null +++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/interior_data_cache_test.cc @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2018, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. */ + +#include "gtest/gtest.h" +#include "rc_rpc_plugin/interior_data_cache_impl.h" + +namespace rc_rpc_plugin_test { + +class InteriorDataCacheTest : public ::testing::Test {}; + +namespace { +const uint32_t time_frame_alowed_requests = 1; +} // namespace + +TEST_F(InteriorDataCacheTest, + InteriorDataCacheDoesNotContainRandomDataInitialy) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + std::string module_type_key = "random_module_type"; + EXPECT_FALSE(cache.Contains(module_type_key)); + auto retrieved_data = cache.Retrieve(module_type_key); + EXPECT_EQ(smart_objects::SmartType_Null, retrieved_data.getType()); +} + +TEST_F(InteriorDataCacheTest, CheckThatCacheContansDataAfterAdding) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + const std::string module_type_key = "random_module_type"; + smart_objects::SmartObject data; + data["key"] = "value"; + + cache.Add(module_type_key, data); + EXPECT_TRUE(cache.Contains(module_type_key)); + auto retrieved_data = cache.Retrieve(module_type_key); + EXPECT_EQ(data, retrieved_data); +} + +TEST_F(InteriorDataCacheTest, DataDoesNotExistAfterClear) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + const std::string module_type_key = "random_module_type"; + smart_objects::SmartObject data; + data["key"] = "value"; + + cache.Add(module_type_key, data); + EXPECT_TRUE(cache.Contains(module_type_key)); + auto Retrieved_data = cache.Retrieve(module_type_key); + EXPECT_EQ(Retrieved_data, data); + cache.Clear(); + auto Retrieved_data_after_clear = cache.Retrieve(module_type_key); + EXPECT_EQ(smart_objects::SmartType_Null, + Retrieved_data_after_clear.getType()); +} + +TEST_F(InteriorDataCacheTest, MultipleDataCached) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + + const std::string module_type_key1 = "random_module_type"; + smart_objects::SmartObject data1; + data1["key"] = "value1"; + cache.Add(module_type_key1, data1); + EXPECT_TRUE(cache.Contains(module_type_key1)); + auto retrieved_data1 = cache.Retrieve(module_type_key1); + EXPECT_EQ(data1, retrieved_data1); + + std::string module_type_key2 = "random_module_type2"; + smart_objects::SmartObject data2; + data2["key"] = "value2"; + cache.Add(module_type_key2, data2); + EXPECT_TRUE(cache.Contains(module_type_key2)); + auto retrieved_data2 = cache.Retrieve(module_type_key2); + EXPECT_EQ(retrieved_data2, data2); + + ASSERT_TRUE(data1 != data2); + EXPECT_TRUE(data2 != retrieved_data1); + EXPECT_TRUE(data1 != retrieved_data2); +} + +TEST_F(InteriorDataCacheTest, RemoveFromChacheSuccessful) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + + const std::string module_type = "random_module_type"; + smart_objects::SmartObject data; + data["key"] = "value1"; + cache.Add(module_type, data); + EXPECT_TRUE(cache.Contains(module_type)); + auto retrieved_data1 = cache.Retrieve(module_type); + EXPECT_EQ(data, retrieved_data1); + + cache.Remove(module_type); + EXPECT_FALSE(cache.Contains(module_type)); + auto retreived = cache.Retrieve(module_type); + EXPECT_EQ(smart_objects::SmartType_Null, retreived.getType()); +} + +TEST_F(InteriorDataCacheTest, RemoveNotExistingNoSideEffects) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + const std::string module_type_key = "random_module_type"; + smart_objects::SmartObject data; + data["key"] = "value"; + + cache.Add(module_type_key, data); + cache.Remove("some other module_type"); + + EXPECT_TRUE(cache.Contains(module_type_key)); + auto retrieved_data = cache.Retrieve(module_type_key); + EXPECT_EQ(data, retrieved_data); +} + +TEST_F(InteriorDataCacheTest, Exist2ModuleTypesRemoveOneAnotherOneLeft) { + rc_rpc_plugin::InteriorDataCacheImpl cache; + + const std::string module_type_key1 = "random_module_type"; + smart_objects::SmartObject data1; + data1["key"] = "value1"; + cache.Add(module_type_key1, data1); + + std::string module_type_key2 = "random_module_type2"; + smart_objects::SmartObject data2; + data2["key"] = "value2"; + cache.Add(module_type_key2, data2); + + ASSERT_TRUE(data1 != data2); + + cache.Remove(module_type_key1); + EXPECT_FALSE(cache.Contains(module_type_key1)); + EXPECT_TRUE(cache.Contains(module_type_key2)); + + auto retrieved_data1 = cache.Retrieve(module_type_key1); + EXPECT_EQ(smart_objects::SmartType_Null, retrieved_data1.getType()); + auto retrieved_data2 = cache.Retrieve(module_type_key2); + EXPECT_EQ(data2, retrieved_data2); +} + +} // rc_rpc_plugin_test -- cgit v1.2.1