Add Interior data cache and interior data manager

Add helpers functions for RC

11 files changed, 1072 insertions, 0 deletions

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 <string>
+#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 <map>
+
+#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<std::string, smart_objects::SmartObject> 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<application_manager::ApplicationSharedPtr,
+                   std::vector<std::string> > 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<std::string, std::deque<TimevalStruct> >
+      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 <map>
+#include <string>
+#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<std::string(const std::string& module_type)>
+  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<application_manager::ApplicationSharedPtr>
+  AppsSubscribedToModuleType(application_manager::ApplicationManager& app_mngr,
+                             const std::string& module_type);
+
+  typedef std::map<application_manager::ApplicationSharedPtr,
+                   std::vector<std::string> > 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 <iostream>
+#include <thread>
+#include <chrono>
+#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<std::string> 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<std::string> 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<std::string>(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<std::string(const std::string& module_type)>
+RCHelpers::GetModuleTypeToDataMapping() {
+  auto mapping_lambda = [](const std::string& module_type) -> std::string {
+    static std::map<std::string, std::string> 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<RCAppExtension>(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<SmartObject>(SmartType_Map);
+  SmartObject& params = (*message)[am_strings::params];
+  SmartObject& msg_params = (*message)[am_strings::msg_params];
+
+  params[am_strings::message_type] =
+      static_cast<int>(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<application_manager::ApplicationSharedPtr>
+RCHelpers::AppsSubscribedToModuleType(
+    application_manager::ApplicationManager& app_mngr,
+    const std::string& module_type) {
+  std::vector<application_manager::ApplicationSharedPtr> 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<std::string> 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 <string>
+#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 <string>
+#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