Merge remote-tracking branch 'origin/develop' into feature/handling_VR_help_requests

# Conflicts:
#	src/components/application_manager/rpc_plugins/sdl_rpc_plugin/test/commands/mobile/set_global_properties_test.cc
#	src/components/application_manager/src/application_manager_impl.cc
#	src/components/application_manager/test/CMakeLists.txt
#	src/components/application_manager/test/application_manager_impl_test.cc
#	src/components/application_manager/test/resumption/resume_ctrl_test.cc
#	src/components/functional_module/test/include/mock_application.h
#	src/components/remote_control/test/include/mock_application.h

57 files changed, 7566 insertions, 0 deletions

diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/CMakeLists.txt b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/CMakeLists.txt
new file mode 100644
index 0000000000..00de927b6e
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/CMakeLists.txt
@@ -0,0 +1,80 @@
+# 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 copyright holders nor the names of their 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_directories(include)
+
+set (COMMANDS_SOURCE_DIR
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/commands
+)
+
+set (MOBILE_COMMANDS_SOURCE_DIR
+  ${COMMANDS_SOURCE_DIR}/mobile
+)
+
+set (HMI_COMMANDS_SOURCE_DIR
+  ${COMMANDS_SOURCE_DIR}/hmi
+)
+
+collect_sources(MOBILE_COMMANDS "${MOBILE_COMMANDS_SOURCE_DIR}")
+collect_sources(HMI_COMMANDS "${HMI_COMMANDS_SOURCE_DIR}")
+collect_sources(PLUGIN_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src")
+collect_sources(COMMANDS_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/commands")
+
+set(LIBRARIES
+  HMI_API
+  MOBILE_API
+  ApplicationManager
+  v4_protocol_v1_2_no_extra
+  SmartObjects
+  Utils
+)
+
+if(ENABLE_LOG)
+  list(APPEND LIBRARIES log4cxx -L${LOG4CXX_LIBS_DIRECTORY})
+endif()
+
+add_library("rc_rpc_plugin" SHARED ${PLUGIN_SOURCES} ${MOBILE_COMMANDS} ${HMI_COMMANDS} ${COMMANDS_SOURCES})
+target_link_libraries("rc_rpc_plugin" ${LIBRARIES})
+
+add_library("RCRpcPluginStaticLib" ${PLUGIN_SOURCES} ${MOBILE_COMMANDS} ${HMI_COMMANDS})
+target_link_libraries("RCRpcPluginStaticLib" ${LIBRARIES})
+
+set(INSTALL_DESTINATION bin)
+
+install(TARGETS rc_rpc_plugin
+  DESTINATION ${INSTALL_DESTINATION}
+  PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
+    GROUP_READ GROUP_EXECUTE
+    WORLD_READ WORLD_EXECUTE
+)
+
+if(BUILD_TESTS)
+  add_subdirectory(test)
+endif()
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_button_press_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_button_press_request.h
new file mode 100644
index 0000000000..fc3721e763
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_button_press_request.h
@@ -0,0 +1,71 @@
+/*
+ * 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_COMMANDS_HMI_RC_BUTTON_PRESS_REQUEST_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_BUTTON_PRESS_REQUEST_H
+
+#include "application_manager/commands/request_to_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCButtonPressRequest
+    : public application_manager::commands::RequestToHMI {
+ public:
+  /**
+   * @brief RCButtonPressRequest class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCButtonPressRequest(const app_mngr::commands::MessageSharedPtr& message,
+                       app_mngr::ApplicationManager& application_manager,
+                       app_mngr::rpc_service::RPCService& rpc_service,
+                       app_mngr::HMICapabilities& hmi_capabilities,
+                       policy::PolicyHandlerInterface& policy_handle,
+                       ResourceAllocationManager& resource_allocation_manager);
+  /**
+   * @brief Execute command
+   */
+  void Run() OVERRIDE;
+  ~RCButtonPressRequest();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_BUTTON_PRESS_REQUEST_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_button_press_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_button_press_response.h
new file mode 100644
index 0000000000..c16f4de0cc
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_button_press_response.h
@@ -0,0 +1,70 @@
+/*
+ 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_COMMANDS_HMI_RC_BUTTON_PRESS_RESPONSE_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_BUTTON_PRESS_RESPONSE_H
+
+#include "application_manager/commands/response_from_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCButtonPressResponse
+    : public application_manager::commands::ResponseFromHMI {
+ public:
+  /**
+   * @brief RCButtonPressResponse class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCButtonPressResponse(const app_mngr::commands::MessageSharedPtr& message,
+                        app_mngr::ApplicationManager& application_manager,
+                        app_mngr::rpc_service::RPCService& rpc_service,
+                        app_mngr::HMICapabilities& hmi_capabilities,
+                        policy::PolicyHandlerInterface& policy_handle,
+                        ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  ~RCButtonPressResponse();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_BUTTON_PRESS_RESPONSE_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_request.h
new file mode 100644
index 0000000000..fc2e0d6536
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_request.h
@@ -0,0 +1,62 @@
+/*
+* 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_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_CONSENT_REQUEST_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_CONSENT_REQUEST_H_
+
+#include "application_manager/commands/request_to_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCGetInteriorVehicleDataConsentRequest
+    : public application_manager::commands::RequestToHMI {
+ public:
+  RCGetInteriorVehicleDataConsentRequest(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+  ~RCGetInteriorVehicleDataConsentRequest();
+};
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_CONSENT_REQUEST_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_response.h
new file mode 100644
index 0000000000..a037d33d5a
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_response.h
@@ -0,0 +1,72 @@
+/*
+ * 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_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_CONSENT_RESPONSE_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_CONSENT_RESPONSE_H_
+
+#include "application_manager/commands/response_from_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCGetInteriorVehicleDataConsentResponse
+    : public application_manager::commands::ResponseFromHMI {
+ public:
+  /**
+   * @brief RCGetInteriorVehicleDataConsentResponse class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCGetInteriorVehicleDataConsentResponse(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  ~RCGetInteriorVehicleDataConsentResponse();
+};
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_CONSENT_RESPONSE_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_request.h
new file mode 100644
index 0000000000..9f7b1211b7
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_request.h
@@ -0,0 +1,62 @@
+/*
+ * 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_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_REQUEST_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_REQUEST_H_
+
+#include "application_manager/commands/request_to_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCGetInteriorVehicleDataRequest
+    : public application_manager::commands::RequestToHMI {
+ public:
+  RCGetInteriorVehicleDataRequest(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+  ~RCGetInteriorVehicleDataRequest();
+};
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_REQUEST_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_response.h
new file mode 100644
index 0000000000..28f9b4b9c7
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_response.h
@@ -0,0 +1,62 @@
+/*
+ * 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_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_RESPONSE_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_RESPONSE_H_
+
+#include "application_manager/commands/response_from_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCGetInteriorVehicleDataResponse
+    : public application_manager::commands::ResponseFromHMI {
+ public:
+  RCGetInteriorVehicleDataResponse(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  ~RCGetInteriorVehicleDataResponse();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_GET_INTERIOR_VEHICLE_DATA_RESPONSE_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_on_interior_vehicle_data_notification.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_on_interior_vehicle_data_notification.h
new file mode 100644
index 0000000000..0afa613c7c
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_on_interior_vehicle_data_notification.h
@@ -0,0 +1,74 @@
+/*
+ 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_COMMANDS_HMI_RC_ON_INTERIOR_VEHICLE_DATA_NOTIFICATION_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_ON_INTERIOR_VEHICLE_DATA_NOTIFICATION_H
+
+#include "application_manager/commands/notification_from_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCOnInteriorVehicleDataNotification
+    : public application_manager::commands::NotificationFromHMI {
+ public:
+  /**
+   * @brief RCOnInteriorVehicleDataNotification class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCOnInteriorVehicleDataNotification(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  ~RCOnInteriorVehicleDataNotification();
+
+  /**
+   * @brief Execute command
+   **/
+  void Run() OVERRIDE;
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_ON_INTERIOR_VEHICLE_DATA_NOTIFICATION_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_on_remote_control_settings_notification.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_on_remote_control_settings_notification.h
new file mode 100644
index 0000000000..b9ab821176
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_on_remote_control_settings_notification.h
@@ -0,0 +1,83 @@
+/*
+ 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_COMMANDS_HMI_RC_ON_REMOTE_CONTROL_SETTINGS_NOTIFICATION_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_ON_REMOTE_CONTROL_SETTINGS_NOTIFICATION_H
+
+#include "application_manager/commands/notification_from_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCOnRemoteControlSettingsNotification
+    : public application_manager::commands::NotificationFromHMI {
+ public:
+  /**
+   * @brief RCOnRemoteControlSettingsNotification class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCOnRemoteControlSettingsNotification(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      rc_rpc_plugin::ResourceAllocationManager& resource_allocation_manager);
+  /**
+   * @brief Execute command
+   **/
+  void Run() OVERRIDE;
+
+  ~RCOnRemoteControlSettingsNotification();
+
+ private:
+  ResourceAllocationManager& resource_allocation_manager_;
+
+  /**
+   * @brief Disalows RC functionality for all RC apps
+   * All registered apps will be unsubsribed from OnInteriorVehicleData
+   * notifications
+   */
+  void DisallowRCFunctionality();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_RC_ON_REMOTE_CONTROL_SETTINGS_NOTIFICATION_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_request.h
new file mode 100644
index 0000000000..194b423b1a
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_request.h
@@ -0,0 +1,70 @@
+/*
+ * 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_COMMANDS_HMI_RC_SET_INTERIOR_VEHICLE_DATA_REQUEST_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_SET_INTERIOR_VEHICLE_DATA_REQUEST_H_
+
+#include "application_manager/commands/request_to_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCSetInteriorVehicleDataRequest
+    : public application_manager::commands::RequestToHMI {
+ public:
+  /**
+   * @brief RCSetInteriorVehicleDataRequest class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCSetInteriorVehicleDataRequest(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+  void Run() OVERRIDE;
+  ~RCSetInteriorVehicleDataRequest();
+};
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_HMI_RC_SET_INTERIOR_VEHICLE_DATA_REQUEST_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_response.h
new file mode 100644
index 0000000000..f23acda4d4
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_response.h
@@ -0,0 +1,71 @@
+/*
+ * 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_COMMANDS_HMI_SET_INTERIOR_VEHICLE_DATA_RESPONSE_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_SET_INTERIOR_VEHICLE_DATA_RESPONSE_H
+
+#include "application_manager/commands/response_from_hmi.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class RCSetInteriorVehicleDataResponse
+    : public application_manager::commands::ResponseFromHMI {
+ public:
+  /**
+   * @brief RCSetInteriorVehicleDataResponse class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCSetInteriorVehicleDataResponse(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  ~RCSetInteriorVehicleDataResponse();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_HMI_SET_INTERIOR_VEHICLE_DATA_RESPONSE_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/button_press_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/button_press_request.h
new file mode 100644
index 0000000000..fa89c10bf9
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/button_press_request.h
@@ -0,0 +1,99 @@
+/*
+ * 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_COMMANDS_BUTTON_PRESS_REQUEST_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_BUTTON_PRESS_REQUEST_H
+
+#include "rc_rpc_plugin/commands/rc_command_request.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class ButtonPressRequest : public RCCommandRequest {
+ public:
+  ButtonPressRequest(const app_mngr::commands::MessageSharedPtr& message,
+                     app_mngr::ApplicationManager& application_manager,
+                     app_mngr::rpc_service::RPCService& rpc_service,
+                     app_mngr::HMICapabilities& hmi_capabilities,
+                     policy::PolicyHandlerInterface& policy_handle,
+                     ResourceAllocationManager& resource_allocation_manager);
+
+  /**
+   * @brief Execute command
+   * send HMI request if message contains appropriate
+   * button name and module type
+   * otherwise sends negative sesponse to mobile
+   */
+  void Execute() FINAL;
+
+  /**
+   * @brief AcquireResource Tries to acquire specific resource
+   * @param message Incoming message containg the resource name
+   * @return Acquire result
+   */
+  AcquireResult::eType AcquireResource(
+      const app_mngr::commands::MessageSharedPtr& message) FINAL;
+
+  /**
+   * @brief IsResourceFree check resource state
+   * @param module_type Resource name
+   * @return True if free, otherwise - false
+   */
+  bool IsResourceFree(const std::string& module_type) const FINAL;
+
+  /**
+   * @brief SetResourceState changes state of resource
+   * @param state State to set for resource
+   */
+  void SetResourceState(const std::string& module_type,
+                        const ResourceState::eType state) FINAL;
+
+  /**
+   * @brief Interface method that is called whenever new event received
+   *
+   * @param event The received event
+   */
+  void on_event(const app_mngr::event_engine::Event& event) FINAL;
+
+  std::string ModuleType() FINAL;
+
+  /**
+   * @brief ButtonPressRequest class destructor
+   */
+  ~ButtonPressRequest();
+};
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_BUTTON_PRESS_REQUEST_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/button_press_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/button_press_response.h
new file mode 100644
index 0000000000..16d7b0e3fe
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/button_press_response.h
@@ -0,0 +1,62 @@
+/*
+ * 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_COMMANDS_BUTTON_PRESS_RESPONSE_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_BUTTON_PRESS_RESPONSE_H
+
+#include "application_manager/commands/command_response_impl.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class ButtonPressResponse
+    : public application_manager::commands::CommandResponseImpl {
+ public:
+  ButtonPressResponse(const app_mngr::commands::MessageSharedPtr& message,
+                      app_mngr::ApplicationManager& application_manager,
+                      app_mngr::rpc_service::RPCService& rpc_service,
+                      app_mngr::HMICapabilities& hmi_capabilities,
+                      policy::PolicyHandlerInterface& policy_handle,
+                      ResourceAllocationManager& resource_allocation_manager);
+  void Run() OVERRIDE;
+  /**
+   * @brief ButtonPressResponse class destructor
+   */
+  ~ButtonPressResponse();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_BUTTON_PRESS_RESPONSE_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_request.h
new file mode 100644
index 0000000000..c2ae0e887f
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_request.h
@@ -0,0 +1,98 @@
+/*
+ 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 copyright holders nor the names of their 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_COMMANDS_MOBILE_GET_INTERIOR_VEHICLE_DATA_REQUEST_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_MOBILE_GET_INTERIOR_VEHICLE_DATA_REQUEST_H_
+
+#include "rc_rpc_plugin/commands/rc_command_request.h"
+#include <string>
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class GetInteriorVehicleDataRequest : public RCCommandRequest {
+ public:
+  GetInteriorVehicleDataRequest(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+  /**
+   * @brief Execute command
+   */
+  void Execute() FINAL;
+
+  /**
+   * @brief Interface method that is called whenever new event received
+   *
+   * @param event The received event
+   */
+  void on_event(const app_mngr::event_engine::Event& event) FINAL;
+
+  /**
+   * @brief GetInteriorVehicleDataRequest class destructor
+   */
+  ~GetInteriorVehicleDataRequest();
+
+ private:
+  /**
+   * @brief Check if app wants to proceed with already setup subscription
+   * @param request_params request parameters to check
+   * @return true if app already subscribed(unsubsribed) for module type but
+   * wants to subscribe(unsubscribe) for the same module again
+   * otherwise - false
+   */
+  bool HasRequestExcessiveSubscription();
+
+  /**
+    * @brief Handle subscription to vehicle data
+    * @param hmi_response json message with response from HMI
+    */
+  void ProccessSubscription(
+      const NsSmartDeviceLink::NsSmartObjects::SmartObject& hmi_response);
+
+  /**
+   * @brief Cuts off subscribe parameter
+   * @param request_params request parameters to handle
+   */
+  void RemoveExcessiveSubscription();
+
+  std::string ModuleType() FINAL;
+  bool excessive_subscription_occured_;
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_MOBILE_GET_INTERIOR_VEHICLE_DATA_REQUEST_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_response.h
new file mode 100644
index 0000000000..78148ab7df
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_response.h
@@ -0,0 +1,62 @@
+/*
+ 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 copyright holders nor the names of their 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_COMMANDS_GET_INTERIOR_VEHICLE_DATA_RESPONSE_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_GET_INTERIOR_VEHICLE_DATA_RESPONSE_H
+
+#include "application_manager/commands/command_response_impl.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class GetInteriorVehicleDataResponse
+    : public application_manager::commands::CommandResponseImpl {
+ public:
+  GetInteriorVehicleDataResponse(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  ~GetInteriorVehicleDataResponse();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_GET_INTERIOR_VEHICLE_DATA_RESPONSE_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/on_interior_vehicle_data_notification.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/on_interior_vehicle_data_notification.h
new file mode 100644
index 0000000000..20a7e69868
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/on_interior_vehicle_data_notification.h
@@ -0,0 +1,65 @@
+/*
+ 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 copyright holders nor the names of their 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_COMMANDS_MOBILE_ON_INTERIOR_VEHICLE_DATA_NOTIFICATION_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_MOBILE_ON_INTERIOR_VEHICLE_DATA_NOTIFICATION_H_
+
+#include <string>
+#include "application_manager/commands/command_notification_impl.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class OnInteriorVehicleDataNotification
+    : public application_manager::commands::CommandNotificationImpl {
+ public:
+  OnInteriorVehicleDataNotification(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handler,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  std::string ModuleType();
+
+  ~OnInteriorVehicleDataNotification();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_MOBILE_ON_INTERIOR_VEHICLE_DATA_NOTIFICATION_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h
new file mode 100644
index 0000000000..83a8dfdd75
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h
@@ -0,0 +1,125 @@
+/*
+ * 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_COMMANDS_SET_INTERIOR_VEHICLE_DATA_REQUEST_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_SET_INTERIOR_VEHICLE_DATA_REQUEST_H
+
+#include "rc_rpc_plugin/commands/rc_command_request.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class SetInteriorVehicleDataRequest : public RCCommandRequest {
+ public:
+  SetInteriorVehicleDataRequest(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      rc_rpc_plugin::ResourceAllocationManager& resource_allocation_manager);
+
+  /**
+   * @brief Execute command
+   */
+  void Execute() FINAL;
+
+  /**
+   * @brief AcquireResource proxy AcquireResource to Resource allocation manager
+   * @param message message of requires contatin module types
+   * @return result of acauiring resources
+   */
+  AcquireResult::eType AcquireResource(
+      const app_mngr::commands::MessageSharedPtr& message) FINAL;
+
+  /**
+   * @brief IsResourceFree check resource state
+   * @param module_type Resource name
+   * @return True if free, otherwise - false
+   */
+  bool IsResourceFree(const std::string& module_type) const FINAL;
+
+  /**
+   * @brief SetResourceState changes state of resource
+   * @param state State to set for resource
+   */
+  void SetResourceState(const std::string& module_type,
+                        const ResourceState::eType state) FINAL;
+
+  /**
+   * @brief Interface method that is called whenever new event received
+   *
+   * @param event The received event
+   */
+  void on_event(const app_mngr::event_engine::Event& event) FINAL;
+
+  /**
+   * @brief Method that check if READ_ONLY parameters present
+   * @param request_params params from received message
+   * @return true if present , false - otherwise
+   */
+  bool AreReadOnlyParamsPresent(const smart_objects::SmartObject& module_data);
+
+  /**
+   * @brief Method that check if all request parameters are READ_ONLY
+   * @param request_params params from received message
+   * @return true if all are read only , false - otherwise
+   */
+  bool AreAllParamsReadOnly(const smart_objects::SmartObject& module_data);
+
+  /**
+   * @brief Method that cuts-off READ_ONLY parameters
+   * @param request_params params to handle
+   */
+  void CutOffReadOnlyParams(smart_objects::SmartObject& module_data);
+
+  std::string ModuleType() FINAL;
+
+  /**
+   * @brief SetInteriorVehicleDataRequest class destructor
+   */
+  ~SetInteriorVehicleDataRequest();
+
+ private:
+  /**
+   * @brief ControlData
+   * @param module_data received params
+   * @return value of module data depending on module type
+   */
+  const smart_objects::SmartObject& ControlData(
+      const smart_objects::SmartObject& module_data);
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_SET_INTERIOR_VEHICLE_DATA_REQUEST_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_response.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_response.h
new file mode 100644
index 0000000000..5661a57c07
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_response.h
@@ -0,0 +1,62 @@
+/*
+ * 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_COMMANDS_SET_INTERIOR_VEHICLE_DATA_RESPONSE_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_SET_INTERIOR_VEHICLE_DATA_RESPONSE_H
+
+#include "application_manager/commands/command_response_impl.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+namespace commands {
+class SetInteriorVehicleDataResponse
+    : public application_manager::commands::CommandResponseImpl {
+ public:
+  SetInteriorVehicleDataResponse(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handle,
+      ResourceAllocationManager& resource_allocation_manager);
+
+  void Run() OVERRIDE;
+
+  ~SetInteriorVehicleDataResponse();
+};
+}  // namespace commands
+}  // namespace rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_COMMANDS_SET_INTERIOR_VEHICLE_DATA_RESPONSE_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/rc_command_request.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/rc_command_request.h
new file mode 100644
index 0000000000..7c5e6f0ebc
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/commands/rc_command_request.h
@@ -0,0 +1,172 @@
+/*
+ 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_COMMANDS_RC_COMMAND_REQUEST_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_RC_COMMAND_REQUEST_H
+
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+#include "application_manager/commands/command_request_impl.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+
+enum TypeAccess { kDisallowed, kAllowed };
+
+namespace commands {
+
+class RCCommandRequest : public app_mngr::commands::CommandRequestImpl {
+ public:
+  /**
+   * @brief RCCommandRequest class constructor
+   * @param message MessageSharedPtr
+   * @param application_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handle PolicyHandlerInterface
+   * @param resource_allocation_manager ResourceAllocationManager
+   **/
+  RCCommandRequest(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::ApplicationManager& application_manager,
+      app_mngr::rpc_service::RPCService& rpc_service,
+      app_mngr::HMICapabilities& hmi_capabilities,
+      policy::PolicyHandlerInterface& policy_handl,
+      rc_rpc_plugin::ResourceAllocationManager& resource_allocation_manager);
+
+  virtual ~RCCommandRequest();
+
+  void onTimeOut() OVERRIDE;
+
+  void Run() OVERRIDE;
+
+  virtual void on_event(const app_mngr::event_engine::Event& event) OVERRIDE;
+
+ protected:
+  bool is_subscribed;
+  ResourceAllocationManager& resource_allocation_manager_;
+  bool auto_allowed_;
+
+  /**
+   * @brief AcquireResource try to allocate resource for application
+   * In case if allocation of resource is not required, return ALLOWED by
+   * default.
+   * This method should be overrided in RPCs that requires resource allocation
+   * @return result of resource allocation, in case if allocation os not
+   * required, return ALLOWED
+   */
+  virtual AcquireResult::eType AcquireResource(
+      const app_mngr::commands::MessageSharedPtr& message) {
+    return AcquireResult::ALLOWED;
+  }
+
+  /**
+   * @brief IsResourceFree check resource state
+   * This is default implementation which has to be redefined for RPCs which
+   * need to manage the resources
+   * @param module_type Resource name
+   * @return True if free, otherwise - false
+   */
+  virtual bool IsResourceFree(const std::string& module_type) const {
+    UNUSED(module_type);
+    return true;
+  }
+  /**
+   * @brief SetResourceState changes state of resource
+   * This is default implementation which has to be redefined for RPCs which
+   * need to manage the resources
+   * @param module_type Resource name
+   * @param State to set for resource
+   */
+  virtual void SetResourceState(const std::string& module_type,
+                                const ResourceState::eType) {}
+
+  /**
+   * Checks if module for application is present in policy table
+   * @param app_id id of application
+   * @param module type Resource name
+   * @return kAllowed if module is present, otherwise - kDisallowed
+   */
+  TypeAccess CheckModule(const std::string& module_type,
+                         application_manager::ApplicationSharedPtr app);
+
+  bool auto_allowed() const {
+    return auto_allowed_;
+  }
+
+  void set_auto_allowed(const bool value) {
+    auto_allowed_ = value;
+  }
+
+  /**
+   * @brief executes specific logic of children classes
+   */
+  void virtual Execute() = 0;
+
+  void set_disallowed_info(const std::string& info) {
+    disallowed_info_ = info;
+  }
+
+  virtual std::string ModuleType() = 0;
+
+ private:
+  /**
+   * @brief CheckDriverConsent checks driver consent defined in policy table
+   * @return True if no consent is required, otherwise - false
+   */
+  bool CheckDriverConsent();
+
+  /**
+   * @brief AcquireResources checks whether resource status is busy or not and
+   * then tries to acquire this resource. In case driver consent is required -
+   * sends consent request to HMI.
+   * @return True in case of resource is free and successfully acquired,
+   * otherwise false
+   */
+  bool AcquireResources();
+  void SendDisallowed(TypeAccess access);
+
+  /**
+   * @brief SendGetUserConsent sends consent request to HMI
+   * @param module_type Resource name
+   */
+  void SendGetUserConsent(const std::string& module_type);
+  void ProcessAccessResponse(const app_mngr::event_engine::Event& event);
+  bool IsInterfaceAvailable(
+      const app_mngr::HmiInterfaces::InterfaceID interface) const;
+
+  std::string disallowed_info_;
+};
+}
+}
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_COMMANDS_RC_COMMAND_REQUEST_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_app_extension.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_app_extension.h
new file mode 100644
index 0000000000..05994492c2
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_app_extension.h
@@ -0,0 +1,85 @@
+/*
+ * 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_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RC_APP_EXTENSION_H_
+#define SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RC_APP_EXTENSION_H_
+
+#include <string>
+#include <set>
+#include "application_manager/app_extension.h"
+
+namespace rc_rpc_plugin {
+class RCAppExtension : public application_manager::AppExtension {
+ public:
+  explicit RCAppExtension(application_manager::AppExtensionUID uid);
+  ~RCAppExtension();
+
+  /**
+   * @brief Subscribe to OnInteriorVehicleDataNotification
+   * @param module interior data specification(zone, data type)
+   */
+  void SubscribeToInteriorVehicleData(const std::string& module_type);
+
+  /**
+   * @brief Unsubscribe from OnInteriorVehicleDataNotification
+   * @param module interior data specification(zone, data type)
+   */
+  void UnsubscribeFromInteriorVehicleData(const std::string& module_type);
+
+  /**
+   * @brief UnsubscribeFromInteriorVehicleData removes all subscriptions for
+   * interior data
+   */
+  void UnsubscribeFromInteriorVehicleData();
+
+  /**
+   * @brief Check if application subscribed to OnInteriorVehicleDataNotification
+   * @param module interior data specification(zone, data type)
+   */
+  bool IsSubscibedToInteriorVehicleData(const std::string& module_type);
+
+ private:
+  std::set<std::string> subscribed_interior_vehicle_data_;
+
+  // AppExtension interface
+ public:
+  void SaveResumptionData(
+      NsSmartDeviceLink::NsSmartObjects::SmartObject& resumption_data) OVERRIDE;
+  void ProcessResumption(const NsSmartDeviceLink::NsSmartObjects::SmartObject&
+                             resumption_data) OVERRIDE;
+};
+
+typedef utils::SharedPtr<RCAppExtension> RCAppExtensionPtr;
+
+}  //  namespace rc_rpc_plugin
+
+#endif  //  SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RC_APP_EXTENSION_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_command_factory.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_command_factory.h
new file mode 100644
index 0000000000..6f101cefef
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_command_factory.h
@@ -0,0 +1,94 @@
+/*
+ * 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_COMMAND_FACTORY_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_COMMAND_FACTORY_H
+
+#include <memory>
+#include "application_manager/command_factory.h"
+#include "application_manager/application_manager.h"
+#include "application_manager/command_factory.h"
+#include "application_manager/rpc_service.h"
+#include "application_manager/hmi_capabilities.h"
+#include "application_manager/policies/policy_handler_interface.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace app_mngr = application_manager;
+using policy::PolicyHandlerInterface;
+class RCCommandFactory : public application_manager::CommandFactory {
+ public:
+  /**
+   * @brief RCCommandFactory class constructor
+   * @param app_manager ApplicationManager
+   * @param rpc_service RPCService
+   * @param hmi_capabilities HMICapabilities
+   * @param policy_handler PolicyHandlerInterface
+   * @param allocation_manager ResourceAllocationManager
+   **/
+  RCCommandFactory(app_mngr::ApplicationManager& app_manager,
+                   app_mngr::rpc_service::RPCService& rpc_service,
+                   app_mngr::HMICapabilities& hmi_capabilities,
+                   policy::PolicyHandlerInterface& policy_handler,
+                   ResourceAllocationManager& allocation_manager);
+  application_manager::CommandSharedPtr CreateCommand(
+      const app_mngr::commands::MessageSharedPtr& message,
+      app_mngr::commands::Command::CommandSource source) OVERRIDE;
+
+  /**
+  * @param int32_t command id
+  * @param CommandSource source
+  * @return return true if command can be create, else return false
+  **/
+  virtual bool IsAbleToProcess(
+      const int32_t,
+      const application_manager::commands::Command::CommandSource)
+      const OVERRIDE;
+
+ private:
+  app_mngr::CommandCreator& get_mobile_creator_factory(
+      mobile_apis::FunctionID::eType id,
+      mobile_apis::messageType::eType message_type) const;
+
+  app_mngr::CommandCreator& get_hmi_creator_factory(
+      hmi_apis::FunctionID::eType id,
+      hmi_apis::messageType::eType message_type) const;
+
+  app_mngr::ApplicationManager& app_manager_;
+  app_mngr::rpc_service::RPCService& rpc_service_;
+  app_mngr::HMICapabilities& hmi_capabilities_;
+  PolicyHandlerInterface& policy_handler_;
+  ResourceAllocationManager& allocation_manager_;
+};
+}  // namespace rc_rpc_plugin
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_COMMAND_FACTORY_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h
new file mode 100644
index 0000000000..e22f2b64a8
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_module_constants.h
@@ -0,0 +1,233 @@
+/*
+ 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_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RC_MODULE_CONSTANTS_H_
+#define SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RC_MODULE_CONSTANTS_H_
+
+namespace rc_rpc_plugin {
+
+namespace strings {
+// RemoteControlCapabilities constants
+const char kclimateControlCapabilities[] = "climateControlCapabilities";
+const char kradioControlCapabilities[] = "radioControlCapabilities";
+const char kbuttonCapabilities[] = "buttonCapabilities";
+// RemoteControlCapabilities constants
+
+const char kRadioControlData[] = "radioControlData";
+const char kClimateControlData[] = "climateControlData";
+}  //  strings
+
+namespace result_codes {
+const char kSuccess[] = "SUCCESS";
+const char kUnsupportedRequest[] = "UNSUPPORTED_REQUEST";
+const char kUnsupportedResource[] = "UNSUPPORTED_RESOURCE";
+const char kDisallowed[] = "DISALLOWED";
+const char kRejected[] = "REJECTED";
+const char kAborted[] = "ABORTED";
+const char kIgnored[] = "IGNORED";
+const char kRetry[] = "RETRY";
+const char kInUse[] = "IN_USE";
+const char kVehicleDataNotAvailable[] = "VEHICLE_DATA_NOT_AVAILABLE";
+const char kTimedOut[] = "TIMED_OUT";
+const char kInvalidData[] = "INVALID_DATA";
+const char kCharLimitExceeded[] = "CHAR_LIMIT_EXCEEDED";
+const char kInvalidId[] = "INVALID_ID";
+const char kDuplicateName[] = "DUPLICATE_NAME";
+const char kApplicationNotRegistered[] = "APPLICATION_NOT_REGISTERED";
+const char kOutOfMemory[] = "OUT_OF_MEMORY";
+const char kTooManyPendingRequests[] = "TOO_MANY_PENDING_REQUESTS";
+const char kWarnings[] = "WARNINGS";
+const char kWrongLanguage[] = "WRONG_LANGUAGE";
+const char kGenericError[] = "GENERIC_ERROR";
+const char kUserDisallowed[] = "USER_DISALLOWED";
+const char kReadOnly[] = "READ_ONLY";
+}  //  result_codes
+
+namespace json_keys {
+const char kParams[] = "params";
+const char kSuccess[] = "success";
+const char kResultCode[] = "resultCode";
+const char kResult[] = "result";
+const char kInfo[] = "info";
+const char kId[] = "id";
+const char kJsonrpc[] = "jsonrpc";
+const char kMethod[] = "method";
+const char kError[] = "error";
+const char kMessage[] = "message";
+const char kData[] = "data";
+const char kAppId[] = "appID";
+const char kCode[] = "code";
+}  //  json_keys
+
+namespace message_params {
+const char kName[] = "name";
+
+// SetInteriorVehicleData request
+const char kModuleData[] = "moduleData";
+// SetInteriorVehicleData request
+
+// GetInteriorVehicleData request
+const char kSubscribe[] = "subscribe";
+// GetInteriorVehicleData request
+
+// GetInteriorVehicleData response
+const char kIsSubscribed[] = "isSubscribed";
+// GetInteriorVehicleData response
+
+// OnRemoteControlSettings notification
+const char kAccessMode[] = "accessMode";
+const char kAllowed[] = "allowed";
+// OnRemoteControlSettings notification
+
+// ButtonPress request
+const char kModuleType[] = "moduleType";
+const char kButtonName[] = "buttonName";
+const char kButtonPressMode[] = "buttonPressMode";
+// ButtonPress request
+
+// RdsData struct
+const char kPS[] = "PS";
+const char kRT[] = "RT";
+const char kCT[] = "CT";
+const char kPI[] = "PI";
+const char kPTY[] = "PTY";
+const char kTA[] = "TA";
+const char kTP[] = "TP";
+const char kREG[] = "REG";
+// RdsData struct
+
+// RadioControlData struct
+const char kFrequencyInteger[] = "frequencyInteger";
+const char kFrequencyFraction[] = "frequencyFraction";
+const char kBand[] = "band";
+const char kRdsData[] = "rdsData";
+const char kAvailableHDs[] = "availableHDs";
+const char kHdChannel[] = "hdChannel";
+const char kSignalStrength[] = "signalStrength";
+const char kSignalChangeThreshold[] = "signalChangeThreshold";
+const char kRadioEnable[] = "radioEnable";
+const char kState[] = "state";
+// RadioControlData struct
+
+// ClimateControlData struct
+const char kFanSpeed[] = "fanSpeed";
+const char kCurrentTemperature[] = "currentTemperature";
+const char kDesiredTemperature[] = "desiredTemperature";
+const char kTemperatureUnit[] = "temperatureUnit";
+const char kACEnable[] = "acEnable";
+const char kCirculateAirEnable[] = "circulateAirEnable";
+const char kAutoModeEnable[] = "autoModeEnable";
+const char kDefrostZone[] = "defrostZone";
+const char kDualModeEnable[] = "dualModeEnable";
+const char kACMaxEnable[] = "acMaxEnable";
+const char kVentilationMode[] = "ventilationMode";
+// ClimateControlData struct
+
+// ModuleData struct
+const char kRadioControlData[] = "radioControlData";
+const char kClimateControlData[] = "climateControlData";
+// ModuleData struct
+
+const char kHMIAppID[] = "appID";
+const char kHmiLevel[] = "hmiLevel";
+const char kSysContext[] = "systemContext";
+const char kAudioState[] = "audioStreamingState";
+}  //  namespace message_params
+
+namespace enums_value {
+
+// ModuleType enum
+const char kClimate[] = "CLIMATE";
+const char kRadio[] = "RADIO";
+// ModuleType enum
+
+// RadioBand enum
+const char kAM[] = "AM";
+const char kFM[] = "FM";
+const char kXM[] = "XM";
+// RadioBand enum
+
+// RadioState enum
+const char kAcquiring[] = "ACQUIRING";
+const char kAcquired[] = "ACQUIRED";
+const char kMulticast[] = "MULTICAST";
+const char kNotFound[] = "NOT_FOUND";
+// RadioState enum
+
+// DefrostZone enum
+const char kFront[] = "FRONT";
+const char kRear[] = "REAR";
+const char kAll[] = "ALL";
+// DefrostZone enum
+
+// TemperatureUnit enum
+const char kFahrenheit[] = "FAHRENHEIT";
+const char kCelsius[] = "CELSIUS";
+// TemperatureUnit enum
+
+// ButtonName enum
+const char kACMax[] = "AC_MAX";
+const char kAC[] = "AC";
+const char kRecirculate[] = "RECIRCULATE";
+const char kFanUp[] = "FAN_UP";
+const char kFanDown[] = "FAN_DOWN";
+const char kTempUp[] = "TEMP_UP";
+const char kTempDown[] = "TEMP_DOWN";
+const char kDefrostMax[] = "DEFROST_MAX";
+const char kDefrost[] = "DEFROST";
+const char kDefrostRear[] = "DEFROST_REAR";
+const char kUpperVent[] = "UPPER_VENT";
+const char kLowerVent[] = "LOWER_VENT";
+const char kVolumeUp[] = "VOLUME_UP";
+const char kVolumeDown[] = "VOLUME_DOWN";
+const char kEject[] = "EJECT";
+const char kSource[] = "SOURCE";
+const char kShuffle[] = "SHUFFLE";
+const char kRepeat[] = "REPEAT";
+// ButtonName enum
+
+// ButtonPressMode enum
+const char kLong[] = "LONG";
+const char kShort[] = "SHORT";
+// ButtonPressMode enum
+
+// Access mode enum
+const char kAutoAllow[] = "AUTO_ALLOW";
+const char kAutoDeny[] = "AUTO_DENY";
+const char kAskDriver[] = "ASK_DRIVER";
+// Access mode enum
+
+}  //  namespace enums_value
+
+}  //  namespace remote_control
+
+#endif  // SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RC_MODULE_CONSTANTS_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_rpc_plugin.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_rpc_plugin.h
new file mode 100644
index 0000000000..910eda6d3c
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/rc_rpc_plugin.h
@@ -0,0 +1,102 @@
+/*
+ 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_PLUGIN_H
+#define SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_PLUGIN_H
+#include "application_manager/plugin_manager/rpc_plugin.h"
+#include "application_manager/command_factory.h"
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+
+namespace rc_rpc_plugin {
+namespace plugins = application_manager::plugin_manager;
+namespace app_mngr = application_manager;
+class RCRPCPlugin : public plugins::RPCPlugin {
+ public:
+  /**
+    * @brief Command initialization function
+    * @param app_manager ApplicationManager
+    * @param rpc_service RPCService
+    * @param hmi_capabilities HMICapabilities
+    * @param policy_handler PolicyHandlerInterface
+    * @return true in case initialization was succesful, false otherwise.
+    **/
+  bool Init(app_mngr::ApplicationManager& app_manager,
+            app_mngr::rpc_service::RPCService& rpc_service,
+            app_mngr::HMICapabilities& hmi_capabilities,
+            policy::PolicyHandlerInterface& policy_handler) OVERRIDE;
+  /**
+  * @param int32_t command id
+  * @param CommandSource source
+  * @return return true if command can be create, else return false
+  **/
+  bool IsAbleToProcess(
+      const int32_t function_id,
+      const app_mngr::commands::Command::CommandSource message_source) OVERRIDE;
+  /**
+   * @brief PluginName plugin name
+   * @return plugin name
+   */
+  std::string PluginName() OVERRIDE;
+  /**
+   * @brief GetCommandFactory get that is able to generate command
+   * from message
+   * @return plugins command factory
+   */
+  app_mngr::CommandFactory& GetCommandFactory() OVERRIDE;
+  /**
+   * @brief OnPolicyEvent Processes policy related events
+   * @param event Policy event
+   */
+  void OnPolicyEvent(app_mngr::plugin_manager::PolicyEvent event) OVERRIDE;
+  /**
+    * @brief OnApplicationEvent Notifies modules on certain application events
+    * @param event Event
+    * @param application Pointer to application struct
+    */
+  void OnApplicationEvent(plugins::ApplicationEvent event,
+                          app_mngr::ApplicationSharedPtr application) OVERRIDE;
+
+  static const uint32_t kRCPluginID = 153;
+
+  typedef std::vector<application_manager::ApplicationSharedPtr> Apps;
+  static Apps GetRCApplications(
+      application_manager::ApplicationManager& app_mngr);
+
+ private:
+  std::unique_ptr<application_manager::CommandFactory> command_factory_;
+  std::unique_ptr<ResourceAllocationManager> resource_allocation_manager_;
+};
+}  // namespace rc_rpc_plugin
+
+extern "C" application_manager::plugin_manager::RPCPlugin* Create();
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_RPC_PLUGINS_RC_RPC_PLUGIN_INCLUDE_RC_RPC_PLUGIN_RC_PLUGIN_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h
new file mode 100644
index 0000000000..0dc8b59f8f
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h
@@ -0,0 +1,151 @@
+/*
+ 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_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_H
+#define SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_H
+#include <string>
+#include "utils/macro.h"
+#include "utils/shared_ptr.h"
+#include "interfaces/HMI_API.h"
+#include "application_manager/plugin_manager/rpc_plugin.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+
+namespace rc_rpc_plugin {
+
+/**
+ * Enum for list of results of allocation resources
+ */
+namespace AcquireResult {
+enum eType { ALLOWED = 0, IN_USE, ASK_DRIVER, REJECTED };
+}
+
+/**
+ * Defines states of acquired resource
+ */
+namespace ResourceState {
+enum eType { FREE = 0, BUSY };
+}
+
+/**
+ * @brief Resources defines list of resources
+ */
+typedef std::vector<std::string> Resources;
+
+class ResourceAllocationManager {
+ public:
+  /**
+   * @brief AcquireResource acquires resource by application
+   * @param module_type resource to acquire
+   * @param app_id application that acquire resource
+   * @return ALLOWED if resource acquired \
+   *         IN_USE  if resource already acquired
+   *         ASK_DRIVER if driver confirmation is required
+   */
+  virtual AcquireResult::eType AcquireResource(const std::string& module_type,
+                                               const uint32_t app_id) = 0;
+
+  /**
+   * @brief SetResourceState changes resource state. Resource must be acquired
+   * beforehand.
+   * @param module_type Resource to change its state
+   * @param app_id Application aquired resource before
+   * @param state State to set for resource
+   */
+  virtual void SetResourceState(const std::string& module_type,
+                                const uint32_t app_id,
+                                const ResourceState::eType state) = 0;
+
+  /**
+   * @brief IsResourceFree check resource state
+   * @param module_type Resource name
+   * @return True if free, otherwise - false
+   */
+  virtual bool IsResourceFree(const std::string& module_type) const = 0;
+
+  /**
+   * @brief AcquireResource forces acquiring resource by application
+   * @param module_type resource to acquire
+   * @param app_id application that acquire resource
+   */
+  virtual void ForceAcquireResource(const std::string& module_type,
+                                    const uint32_t app_id) = 0;
+
+  /**
+   * @brief OnDriverDisallowed callback for rejecting acquiring resource
+   * @param module_type resource type
+   * @param app_id application id
+   */
+  virtual void OnDriverDisallowed(const std::string& module_type,
+                                  const uint32_t app_id) = 0;
+
+  /**
+   * @brief OnApplicationEvent Processes application related events
+   * @param event Event
+   * @param application Pointer to application struct
+   */
+  virtual void OnApplicationEvent(
+      application_manager::plugin_manager::ApplicationEvent event,
+      application_manager::ApplicationSharedPtr application) = 0;
+
+  /**
+   * @brief OnPolicyEvent Processes policy related events
+   * @param event Policy event
+   */
+  virtual void OnPolicyEvent(
+      application_manager::plugin_manager::PolicyEvent event) = 0;
+
+  /**
+   * @brief Set current access mode for acquiring resource
+   * @param access_mode
+   */
+  virtual void SetAccessMode(
+      const hmi_apis::Common_RCAccessMode::eType access_mode) = 0;
+
+  /**
+   * @brief Get last set access mode for acquiring resource
+   * @param access_mode
+   */
+  virtual hmi_apis::Common_RCAccessMode::eType GetAccessMode() const = 0;
+
+  /**
+   * @brief Remove all information about all allocations
+   */
+  virtual void ResetAllAllocations() = 0;
+
+  virtual RCAppExtensionPtr GetApplicationExtention(
+      application_manager::ApplicationSharedPtr application) = 0;
+
+  virtual ~ResourceAllocationManager() {}
+};
+
+}  // namespace rc_rpc_plugin
+#endif  // SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager_impl.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager_impl.h
new file mode 100644
index 0000000000..bb875bb180
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager_impl.h
@@ -0,0 +1,210 @@
+/*
+ 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_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
+#define SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+#include "application_manager/application_impl.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+#include "utils/macro.h"
+#include "utils/lock.h"
+
+namespace rc_rpc_plugin {
+
+typedef std::vector<application_manager::ApplicationSharedPtr> Apps;
+
+class ResourceAllocationManagerImpl : public ResourceAllocationManager {
+ public:
+  ResourceAllocationManagerImpl(
+      application_manager::ApplicationManager& app_mngr,
+      application_manager::rpc_service::RPCService& rpc_service);
+
+  ~ResourceAllocationManagerImpl();
+
+  /**
+   * @brief AcquireResource forces acquiring resource by application
+   * @param module_type resource to acquire
+   * @param app_id application that acquire resourc
+   * @return result of acauiring resources
+   */
+  AcquireResult::eType AcquireResource(const std::string& module_type,
+                                       const uint32_t app_id) OVERRIDE FINAL;
+  /**
+   * @brief ForceAcquireResource forces acquiring resource by application
+   * @param module_type resource to acquire
+   * @param app_id application that acquire resource
+   */
+  void ForceAcquireResource(const std::string& module_type,
+                            const uint32_t app_id) FINAL;
+
+  /**
+    * @brief SetResourceState changes resource state. Resource must be acquired
+    * beforehand.
+    * @param module_type Resource to change its state
+    * @param app_id Application aquired resource before
+    * @param state State to set for resource
+    */
+  void SetResourceState(const std::string& module_type,
+                        const uint32_t app_id,
+                        const ResourceState::eType state) FINAL;
+
+  /**
+   * @brief IsResourceFree check resource state
+   * @param module_type Resource name
+   * @return True if free, otherwise - false
+   */
+  bool IsResourceFree(const std::string& module_type) const FINAL;
+
+  void SetAccessMode(
+      const hmi_apis::Common_RCAccessMode::eType access_mode) FINAL;
+
+  hmi_apis::Common_RCAccessMode::eType GetAccessMode() const FINAL;
+
+  void OnDriverDisallowed(const std::string& module_type,
+                          const uint32_t app_id) FINAL;
+
+  /**
+   * @brief OnApplicationEvent Notifies modules on certain application events
+   * @param event Event
+   * @param application Pointer to application struct
+   */
+  void OnApplicationEvent(
+      application_manager::plugin_manager::ApplicationEvent event,
+      application_manager::ApplicationSharedPtr application) FINAL;
+
+  /**
+   * @brief OnPolicyEvent Processes policy related events
+   * @param event Policy event
+   */
+  void OnPolicyEvent(
+      application_manager::plugin_manager::PolicyEvent event) FINAL;
+
+  void ResetAllAllocations() FINAL;
+
+  /**
+   * @brief GetApplicationExtention Provides access to application RC extention
+   * @param application Application
+   * @return Pointer to RC extention of application or NULL if not available
+   */
+  RCAppExtensionPtr GetApplicationExtention(
+      application_manager::ApplicationSharedPtr application) FINAL;
+
+ private:
+  /**
+   * @brief IsModuleTypeRejected check if current resource was rejected by
+   * driver for current application
+   * @param module_type resource to check
+   * @param app_id application id
+   * @return true if current resource was rejected by driver for current
+   * application, otherwise - false
+   */
+  bool IsModuleTypeRejected(const std::string& module_type,
+                            const uint32_t app_id);
+
+  /**
+   * @brief ReleaseResource Releases resource acquired by application
+   * @param module_type Module name
+   * @param application_id Application id
+   */
+  void ReleaseResource(const std::string& module_type,
+                       const uint32_t application_id);
+
+  /**
+   * @brief GetAcquiredResources Provides resources acquired by particular
+   * application currently
+   * @param application_id Application id
+   * @return List of acquired resources by specific application
+   */
+  Resources GetAcquiredResources(const uint32_t application_id) const;
+
+  /**
+   * @brief ProcessApplicationPolicyUpdate Checks if allowed modules list is
+   * changed for registered RC applications and releases in case some modules
+   * now out of the list
+   */
+  void ProcessApplicationPolicyUpdate();
+
+  /**
+   * @brief RemoveAppsSubscriptions Removes subscriptions for interior data for
+   * applications in the list
+   * @param apps Application list
+   */
+  void RemoveAppsSubscriptions(const Apps& apps);
+
+  /**
+   * @brief SetResourceAquired mark resourse as aquired and process logic of
+   * changing state of aquired resources
+   * @param module_type resource name
+   * @param app applicastion that aquire resource
+   */
+  void SetResourceAquired(const std::string& module_type,
+                          const uint32_t app_id);
+  /**
+   * @brief SetResourceFree mark resourse as free and process logic of
+   * changing state of aquired resources
+   * @param module_type resource name
+   * @param app applicastion that aquire resource
+   */
+  void SetResourceFree(const std::string& module_type, const uint32_t app_id);
+
+  std::vector<std::string> all_supported_modules();
+  /**
+   * @brief AllocatedResources contains link between resource and application
+   * owning that resource
+   */
+  typedef std::map<std::string, uint32_t> AllocatedResources;
+  AllocatedResources allocated_resources_;
+  mutable sync_primitives::Lock allocated_resources_lock_;
+
+  /**
+   * @brief ResourcesState contains states of ALLOCATED resources
+   */
+  typedef std::map<std::string, ResourceState::eType> ResourcesState;
+  ResourcesState resources_state_;
+  mutable sync_primitives::Lock resources_state_lock_;
+
+  /**
+   * @brief RejectedResources type for connecting list of resources rejected by
+   * driver for application
+   * application_id : [vector of rejected resources]
+   */
+  typedef std::map<uint32_t, std::vector<std::string> > RejectedResources;
+  RejectedResources rejected_resources_for_application_;
+  mutable sync_primitives::Lock rejected_resources_for_application_lock_;
+
+  hmi_apis::Common_RCAccessMode::eType current_access_mode_;
+  application_manager::ApplicationManager& app_mngr_;
+  application_manager::rpc_service::RPCService& rpc_service_;
+};
+}  // rc_rpc_plugin
+
+#endif  // SRC_COMPONENTS_REMOTE_CONTROL_INCLUDE_REMOTE_CONTROL_RESOURCE_ALLOCATION_IMPL_H
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_button_press_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_button_press_request.cc
new file mode 100644
index 0000000000..d392420238
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_button_press_request.cc
@@ -0,0 +1,62 @@
+/*
+ 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 "rc_rpc_plugin/commands/hmi/rc_button_press_request.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCButtonPressRequest::RCButtonPressRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::RequestToHMI(message,
+                                                  application_manager,
+                                                  rpc_service,
+                                                  hmi_capabilities,
+                                                  policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+RCButtonPressRequest::~RCButtonPressRequest() {}
+
+void RCButtonPressRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  SendRequest();
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_button_press_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_button_press_response.cc
new file mode 100644
index 0000000000..c7c11354c7
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_button_press_response.cc
@@ -0,0 +1,66 @@
+/*
+ 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 "rc_rpc_plugin/commands/hmi/rc_button_press_response.h"
+#include "application_manager/event_engine/event.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCButtonPressResponse::RCButtonPressResponse(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::ResponseFromHMI(message,
+                                                     application_manager,
+                                                     rpc_service,
+                                                     hmi_capabilities,
+                                                     policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+void RCButtonPressResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  app_mngr::event_engine::Event event(
+      hmi_apis::FunctionID::Buttons_ButtonPress);
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+RCButtonPressResponse::~RCButtonPressResponse() {}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_consent_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_consent_request.cc
new file mode 100644
index 0000000000..875f1c8fbf
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_consent_request.cc
@@ -0,0 +1,63 @@
+/*
+ * 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 "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_request.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCGetInteriorVehicleDataConsentRequest::RCGetInteriorVehicleDataConsentRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::RequestToHMI(message,
+                                                  application_manager,
+                                                  rpc_service,
+                                                  hmi_capabilities,
+                                                  policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+RCGetInteriorVehicleDataConsentRequest::
+    ~RCGetInteriorVehicleDataConsentRequest() {}
+
+void RCGetInteriorVehicleDataConsentRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  SendRequest();
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_consent_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_consent_response.cc
new file mode 100644
index 0000000000..3a9bb12df1
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_consent_response.cc
@@ -0,0 +1,69 @@
+/*
+ * 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 "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_response.h"
+#include "application_manager/event_engine/event.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCGetInteriorVehicleDataConsentResponse::
+    RCGetInteriorVehicleDataConsentResponse(
+        const app_mngr::commands::MessageSharedPtr& message,
+        app_mngr::ApplicationManager& application_manager,
+        app_mngr::rpc_service::RPCService& rpc_service,
+        app_mngr::HMICapabilities& hmi_capabilities,
+        policy::PolicyHandlerInterface& policy_handle,
+        ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::ResponseFromHMI(message,
+                                                     application_manager,
+                                                     rpc_service,
+                                                     hmi_capabilities,
+                                                     policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+void RCGetInteriorVehicleDataConsentResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  app_mngr::event_engine::Event event(
+      hmi_apis::FunctionID::RC_GetInteriorVehicleDataConsent);
+
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+RCGetInteriorVehicleDataConsentResponse::
+    ~RCGetInteriorVehicleDataConsentResponse() {}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_request.cc
new file mode 100644
index 0000000000..0bb5f73c1b
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_request.cc
@@ -0,0 +1,62 @@
+/*
+ * 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 "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_request.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCGetInteriorVehicleDataRequest::RCGetInteriorVehicleDataRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::RequestToHMI(message,
+                                                  application_manager,
+                                                  rpc_service,
+                                                  hmi_capabilities,
+                                                  policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+RCGetInteriorVehicleDataRequest::~RCGetInteriorVehicleDataRequest() {}
+
+void RCGetInteriorVehicleDataRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  SendRequest();
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_response.cc
new file mode 100644
index 0000000000..f12512a38d
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_get_interior_vehicle_data_response.cc
@@ -0,0 +1,66 @@
+/*
+ * 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 "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_response.h"
+#include "application_manager/event_engine/event.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCGetInteriorVehicleDataResponse::RCGetInteriorVehicleDataResponse(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::ResponseFromHMI(message,
+                                                     application_manager,
+                                                     rpc_service,
+                                                     hmi_capabilities,
+                                                     policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+void RCGetInteriorVehicleDataResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  app_mngr::event_engine::Event event(
+      hmi_apis::FunctionID::RC_GetInteriorVehicleData);
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+RCGetInteriorVehicleDataResponse::~RCGetInteriorVehicleDataResponse() {}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_on_interior_vehicle_data_notification.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_on_interior_vehicle_data_notification.cc
new file mode 100644
index 0000000000..487193bc4d
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_on_interior_vehicle_data_notification.cc
@@ -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.
+ */
+
+#include "rc_rpc_plugin/commands/hmi/rc_on_interior_vehicle_data_notification.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCOnInteriorVehicleDataNotification::RCOnInteriorVehicleDataNotification(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::NotificationFromHMI(message,
+                                                         application_manager,
+                                                         rpc_service,
+                                                         hmi_capabilities,
+                                                         policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+RCOnInteriorVehicleDataNotification::~RCOnInteriorVehicleDataNotification() {}
+
+void RCOnInteriorVehicleDataNotification::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  (*message_)[app_mngr::strings::params][app_mngr::strings::function_id] =
+      static_cast<int>(mobile_apis::FunctionID::eType::OnInteriorVehicleDataID);
+  SendNotificationToMobile(message_);
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_on_remote_control_settings_notification.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_on_remote_control_settings_notification.cc
new file mode 100644
index 0000000000..817223a369
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_on_remote_control_settings_notification.cc
@@ -0,0 +1,157 @@
+/*
+ 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 "rc_rpc_plugin/commands/hmi/rc_on_remote_control_settings_notification.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+namespace {
+std::map<std::string, hmi_apis::Common_RCAccessMode::eType> access_modes{
+    {enums_value::kAutoAllow, hmi_apis::Common_RCAccessMode::AUTO_ALLOW},
+    {enums_value::kAutoDeny, hmi_apis::Common_RCAccessMode::AUTO_DENY},
+    {enums_value::kAskDriver, hmi_apis::Common_RCAccessMode::ASK_DRIVER}};
+}
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+RCOnRemoteControlSettingsNotification::RCOnRemoteControlSettingsNotification(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::NotificationFromHMI(message,
+                                                         application_manager,
+                                                         rpc_service,
+                                                         hmi_capabilities,
+                                                         policy_handle)
+    , resource_allocation_manager_(resource_allocation_manager) {}
+
+RCOnRemoteControlSettingsNotification::
+    ~RCOnRemoteControlSettingsNotification() {}
+
+hmi_apis::Common_RCAccessMode::eType AccessModeFromString(
+    const std::string& access_mode) {
+  std::map<std::string, hmi_apis::Common_RCAccessMode::eType>::const_iterator
+      mode = access_modes.find(access_mode);
+  return access_modes.end() != mode
+             ? mode->second
+             : hmi_apis::Common_RCAccessMode::INVALID_ENUM;
+}
+
+std::string AccessModeToString(
+    const hmi_apis::Common_RCAccessMode::eType access_mode) {
+  std::map<std::string, hmi_apis::Common_RCAccessMode::eType>::const_iterator
+      it = access_modes.begin();
+  for (; access_modes.end() != it; ++it) {
+    if (access_mode == it->second) {
+      return it->first;
+    }
+  }
+  const std::string error = "UNKNOW_ACCESS_MODE";
+  DCHECK_OR_RETURN(false, error);
+  return error;
+}
+
+void UnsubscribeFromInteriorVehicleDataForAllModules(
+    RCAppExtensionPtr extension) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  extension->UnsubscribeFromInteriorVehicleData(enums_value::kClimate);
+  extension->UnsubscribeFromInteriorVehicleData(enums_value::kRadio);
+}
+
+void RCOnRemoteControlSettingsNotification::DisallowRCFunctionality() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  typedef std::vector<application_manager::ApplicationSharedPtr> Apps;
+  Apps apps = RCRPCPlugin::GetRCApplications(application_manager_);
+  for (Apps::iterator it = apps.begin(); it != apps.end(); ++it) {
+    application_manager::ApplicationSharedPtr app = *it;
+    DCHECK(app);
+    application_manager_.ChangeAppsHMILevel(
+        app->app_id(), mobile_apis::HMILevel::eType::HMI_NONE);
+
+    const RCAppExtensionPtr extension =
+        application_manager::AppExtensionPtr::static_pointer_cast<
+            RCAppExtension>(app->QueryInterface(RCRPCPlugin::kRCPluginID));
+    if (extension) {
+      UnsubscribeFromInteriorVehicleDataForAllModules(extension);
+    }
+  }
+}
+
+void RCOnRemoteControlSettingsNotification::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  if (!(*message_)[app_mngr::strings::msg_params].keyExists(
+          message_params::kAllowed)) {
+    LOG4CXX_DEBUG(logger_,
+                  "Notification is ignored due to \"allow\" parameter absense");
+    LOG4CXX_DEBUG(logger_, "RC Functionality remains unchanged");
+    return;
+  }
+
+  const bool is_allowed =
+      (*message_)[app_mngr::strings::msg_params][message_params::kAllowed]
+          .asBool();
+  if (is_allowed) {
+    hmi_apis::Common_RCAccessMode::eType access_mode =
+        hmi_apis::Common_RCAccessMode::INVALID_ENUM;
+    LOG4CXX_DEBUG(logger_, "Allowing RC Functionality");
+    if ((*message_)[app_mngr::strings::msg_params].keyExists(
+            message_params::kAccessMode)) {
+      access_mode = static_cast<hmi_apis::Common_RCAccessMode::eType>(
+          (*message_)[app_mngr::strings::msg_params]
+                     [message_params::kAccessMode].asUInt());
+      LOG4CXX_DEBUG(
+          logger_,
+          "Setting up access mode : " << AccessModeToString(access_mode));
+    } else {
+      access_mode = resource_allocation_manager_.GetAccessMode();
+      LOG4CXX_DEBUG(logger_,
+                    "No access mode received. Using last known: "
+                        << AccessModeToString(access_mode));
+    }
+    resource_allocation_manager_.SetAccessMode(access_mode);
+  } else {
+    LOG4CXX_DEBUG(logger_, "Disallowing RC Functionality");
+    DisallowRCFunctionality();
+    resource_allocation_manager_.ResetAllAllocations();
+  }
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_set_interior_vehicle_data_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_set_interior_vehicle_data_request.cc
new file mode 100644
index 0000000000..69ceed17e9
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_set_interior_vehicle_data_request.cc
@@ -0,0 +1,61 @@
+/*
+ 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 "rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_request.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCSetInteriorVehicleDataRequest::RCSetInteriorVehicleDataRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::RequestToHMI(message,
+                                                  application_manager,
+                                                  rpc_service,
+                                                  hmi_capabilities,
+                                                  policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+RCSetInteriorVehicleDataRequest::~RCSetInteriorVehicleDataRequest() {}
+
+void RCSetInteriorVehicleDataRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  SendRequest();
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_set_interior_vehicle_data_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_set_interior_vehicle_data_response.cc
new file mode 100644
index 0000000000..42c2452943
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/hmi/rc_set_interior_vehicle_data_response.cc
@@ -0,0 +1,66 @@
+/*
+ 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 "rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_response.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCSetInteriorVehicleDataResponse::RCSetInteriorVehicleDataResponse(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::ResponseFromHMI(message,
+                                                     application_manager,
+                                                     rpc_service,
+                                                     hmi_capabilities,
+                                                     policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+
+void RCSetInteriorVehicleDataResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  app_mngr::event_engine::Event event(
+      hmi_apis::FunctionID::RC_SetInteriorVehicleData);
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+RCSetInteriorVehicleDataResponse::~RCSetInteriorVehicleDataResponse() {}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/button_press_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/button_press_request.cc
new file mode 100644
index 0000000000..88e4ebaa3c
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/button_press_request.cc
@@ -0,0 +1,299 @@
+/*
+ * 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 "rc_rpc_plugin/commands/mobile/button_press_request.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "smart_objects/enum_schema_item.h"
+#include "utils/macro.h"
+#include "json/json.h"
+#include "utils/helpers.h"
+#include "interfaces/MOBILE_API.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+using namespace json_keys;
+using namespace message_params;
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+typedef std::map<std::string, mobile_apis::ButtonName::eType> ButtonsMap;
+
+ButtonPressRequest::ButtonPressRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : RCCommandRequest(message,
+                       application_manager,
+                       rpc_service,
+                       hmi_capabilities,
+                       policy_handle,
+                       resource_allocation_manager) {}
+
+ButtonPressRequest::~ButtonPressRequest() {}
+
+const std::vector<std::string> buttons_climate() {
+  std::vector<std::string> data;
+  data.push_back(enums_value::kACMax);
+  data.push_back(enums_value::kAC);
+  data.push_back(enums_value::kRecirculate);
+  data.push_back(enums_value::kFanUp);
+  data.push_back(enums_value::kFanDown);
+  data.push_back(enums_value::kTempUp);
+  data.push_back(enums_value::kTempDown);
+  data.push_back(enums_value::kDefrostMax);
+  data.push_back(enums_value::kDefrost);
+  data.push_back(enums_value::kDefrostRear);
+  data.push_back(enums_value::kUpperVent);
+  data.push_back(enums_value::kLowerVent);
+  return data;
+}
+
+const std::vector<std::string> buttons_radio() {
+  std::vector<std::string> data;
+  data.push_back(enums_value::kVolumeUp);
+  data.push_back(enums_value::kVolumeDown);
+  data.push_back(enums_value::kEject);
+  data.push_back(enums_value::kSource);
+  data.push_back(enums_value::kShuffle);
+  data.push_back(enums_value::kRepeat);
+  return data;
+}
+
+const ButtonsMap buttons_map() {
+  using namespace mobile_apis;
+
+  ButtonsMap buttons_map;
+  buttons_map[enums_value::kACMax] = ButtonName::AC_MAX;
+  buttons_map[enums_value::kAC] = ButtonName::AC;
+  buttons_map[enums_value::kRecirculate] = ButtonName::RECIRCULATE;
+  buttons_map[enums_value::kFanUp] = ButtonName::FAN_UP;
+  buttons_map[enums_value::kFanDown] = ButtonName::FAN_DOWN;
+  buttons_map[enums_value::kTempUp] = ButtonName::TEMP_UP;
+  buttons_map[enums_value::kTempDown] = ButtonName::TEMP_DOWN;
+  buttons_map[enums_value::kDefrostMax] = ButtonName::DEFROST_MAX;
+  buttons_map[enums_value::kDefrost] = ButtonName::DEFROST;
+  buttons_map[enums_value::kDefrostRear] = ButtonName::DEFROST_REAR;
+  buttons_map[enums_value::kUpperVent] = ButtonName::UPPER_VENT;
+  buttons_map[enums_value::kLowerVent] = ButtonName::LOWER_VENT;
+  buttons_map[enums_value::kVolumeUp] = ButtonName::VOLUME_UP;
+  buttons_map[enums_value::kVolumeDown] = ButtonName::VOLUME_DOWN;
+  buttons_map[enums_value::kEject] = ButtonName::EJECT;
+  buttons_map[enums_value::kSource] = ButtonName::SOURCE;
+  buttons_map[enums_value::kShuffle] = ButtonName::SHUFFLE;
+  buttons_map[enums_value::kRepeat] = ButtonName::REPEAT;
+
+  return buttons_map;
+}
+
+bool CheckIfButtonExistInRCCaps(
+    const smart_objects::SmartObject& rc_capabilities,
+    const mobile_apis::ButtonName::eType button) {
+  if (rc_capabilities.keyExists(strings::kbuttonCapabilities)) {
+    const smart_objects::SmartObject& button_caps =
+        rc_capabilities[strings::kbuttonCapabilities];
+    auto it = button_caps.asArray()->begin();
+    for (; it != button_caps.asArray()->end(); ++it) {
+      smart_objects::SmartObject& so = *it;
+      int64_t current_id = so[message_params::kName].asInt();
+      if (-1 == current_id) {
+        // capabilities received from HMI contains enum values
+        // capabilities loaded from file contains string values
+        // TODO : unificate capabilities storing
+        const std::string& bt_name = so[message_params::kName].asString();
+        static ButtonsMap btn_map = buttons_map();
+        current_id = btn_map[bt_name];
+      }
+      const mobile_apis::ButtonName::eType current_button =
+          static_cast<mobile_apis::ButtonName::eType>(current_id);
+      if (current_button == button) {
+        LOG4CXX_TRACE(logger_,
+                      "Button id " << current_button
+                                   << " exist in capabilities");
+        return true;
+      }
+    }
+  }
+  LOG4CXX_TRACE(logger_,
+                "Button id " << button << " do not exist in capabilities");
+  return false;
+}
+
+bool CheckButtonName(const std::string& module_type,
+                     const std::string& button_name,
+                     const smart_objects::SmartObject* rc_capabilities) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (rc_capabilities == NULL) {
+    LOG4CXX_ERROR(logger_, "No remote controll capabilities available");
+    return false;
+  }
+
+  if (enums_value::kRadio == module_type) {
+    if (!helpers::in_range(buttons_radio(), button_name)) {
+      LOG4CXX_WARN(logger_,
+                   "Trying to acceess climate button with module type radio");
+      return false;
+    }
+  }
+
+  if (enums_value::kClimate == module_type) {
+    if (!helpers::in_range(buttons_climate(), button_name)) {
+      LOG4CXX_WARN(logger_,
+                   "Trying to acceess radio button with module type climate");
+      return false;
+    }
+  }
+  return true;
+}
+
+void ButtonPressRequest::Execute() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  const char* button_name;
+  NsSmartDeviceLink::NsSmartObjects::
+      EnumConversionHelper<mobile_apis::ButtonName::eType>::EnumToCString(
+          static_cast<mobile_apis::ButtonName::eType>(
+              (*message_)[app_mngr::strings::msg_params]
+                         [message_params::kButtonName].asUInt()),
+          &button_name);
+
+  const std::string module_type = ModuleType();
+  static ButtonsMap btn_map = buttons_map();
+  mobile_apis::ButtonName::eType button_id =
+      mobile_apis::ButtonName::INVALID_ENUM;
+  if (btn_map.end() != btn_map.find(button_name)) {
+    button_id = btn_map[button_name];
+  }
+
+  const smart_objects::SmartObject* rc_capabilities =
+      hmi_capabilities_.rc_capability();
+  const bool button_name_matches_module_type =
+      CheckButtonName(module_type, button_name, rc_capabilities);
+  const bool button_id_exist_in_caps =
+      rc_capabilities &&
+      CheckIfButtonExistInRCCaps(*rc_capabilities, button_id);
+
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(connection_key());
+
+  (*message_)[app_mngr::strings::msg_params][app_mngr::strings::app_id] =
+      app->app_id();
+
+  if (button_name_matches_module_type && button_id_exist_in_caps) {
+    SendHMIRequest(hmi_apis::FunctionID::Buttons_ButtonPress,
+                   &(*message_)[app_mngr::strings::msg_params],
+                   true);
+  } else if (!button_name_matches_module_type) {
+    LOG4CXX_WARN(logger_, "Request module type and button name mismatch!");
+    SetResourceState(module_type, ResourceState::FREE);
+    SendResponse(false,
+                 mobile_apis::Result::INVALID_DATA,
+                 "Request module type and button name mismatch!");
+  } else {
+    LOG4CXX_WARN(logger_, "Requested button is not exists in capabilities!");
+    SetResourceState(module_type, ResourceState::FREE);
+    SendResponse(false,
+                 mobile_apis::Result::UNSUPPORTED_RESOURCE,
+                 "Requested button is not exists in capabilities!");
+  }
+}
+
+AcquireResult::eType ButtonPressRequest::AcquireResource(
+    const app_mngr::commands::MessageSharedPtr& message) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const std::string module_type = ModuleType();
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  return resource_allocation_manager_.AcquireResource(module_type,
+                                                      app->app_id());
+}
+
+bool ButtonPressRequest::IsResourceFree(const std::string& module_type) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return resource_allocation_manager_.IsResourceFree(module_type);
+}
+
+void ButtonPressRequest::SetResourceState(const std::string& module_type,
+                                          const ResourceState::eType state) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  resource_allocation_manager_.SetResourceState(
+      module_type, app->app_id(), state);
+}
+
+void ButtonPressRequest::on_event(const app_mngr::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  RCCommandRequest::on_event(event);
+
+  if (hmi_apis::FunctionID::Buttons_ButtonPress != event.id()) {
+    return;
+  }
+
+  const smart_objects::SmartObject& message = event.smart_object();
+  mobile_apis::Result::eType result_code =
+      GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
+          message[app_mngr::strings::params][app_mngr::hmi_response::code]
+              .asUInt()));
+
+  bool result =
+      helpers::Compare<mobile_apis::Result::eType, helpers::EQ, helpers::ONE>(
+          result_code,
+          mobile_apis::Result::SUCCESS,
+          mobile_apis::Result::WARNINGS);
+
+  if (mobile_apis::Result::READ_ONLY == result_code) {
+    result = false;
+    result_code = mobile_apis::Result::GENERIC_ERROR;
+  }
+  std::string response_info;
+  GetInfo(message, response_info);
+  SetResourceState(ModuleType(), ResourceState::FREE);
+  SendResponse(result, result_code, response_info.c_str());
+}
+
+std::string ButtonPressRequest::ModuleType() {
+  mobile_apis::ModuleType::eType module_type = static_cast<
+      mobile_apis::ModuleType::eType>(
+      (*message_)[app_mngr::strings::msg_params][message_params::kModuleType]
+          .asUInt());
+  const char* str;
+  const bool ok = NsSmartDeviceLink::NsSmartObjects::EnumConversionHelper<
+      mobile_apis::ModuleType::eType>::EnumToCString(module_type, &str);
+  return ok ? str : "unknown";
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/button_press_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/button_press_response.cc
new file mode 100644
index 0000000000..dfdb128322
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/button_press_response.cc
@@ -0,0 +1,61 @@
+/*
+ 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 "rc_rpc_plugin/commands/mobile/button_press_response.h"
+#include "application_manager/rpc_service.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+ButtonPressResponse::ButtonPressResponse(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::CommandResponseImpl(message,
+                                                         application_manager,
+                                                         rpc_service,
+                                                         hmi_capabilities,
+                                                         policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+ButtonPressResponse::~ButtonPressResponse() {}
+
+void ButtonPressResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  application_manager_.GetRPCService().SendMessageToMobile(message_);
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/get_interior_vehicle_data_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/get_interior_vehicle_data_request.cc
new file mode 100644
index 0000000000..38f94637c2
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/get_interior_vehicle_data_request.cc
@@ -0,0 +1,292 @@
+/*
+ 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 copyright holders nor the names of their 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 "rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "smart_objects/enum_schema_item.h"
+#include "utils/macro.h"
+#include "interfaces/MOBILE_API.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+using namespace json_keys;
+using namespace message_params;
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+GetInteriorVehicleDataRequest::GetInteriorVehicleDataRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : RCCommandRequest(message,
+                       application_manager,
+                       rpc_service,
+                       hmi_capabilities,
+                       policy_handle,
+                       resource_allocation_manager)
+    , excessive_subscription_occured_(false) {}
+
+bool CheckIfModuleTypeExistInCapabilities(
+    const smart_objects::SmartObject& rc_capabilities,
+    const std::string& module_type) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (enums_value::kRadio == module_type &&
+      !rc_capabilities.keyExists(strings::kradioControlCapabilities)) {
+    LOG4CXX_DEBUG(logger_, " Radio control capabilities not present");
+    return false;
+  }
+  if (enums_value::kClimate == module_type &&
+      !rc_capabilities.keyExists(strings::kclimateControlCapabilities)) {
+    LOG4CXX_DEBUG(logger_, " Climate control capabilities not present");
+    return false;
+  }
+
+  return true;
+}
+
+void GetInteriorVehicleDataRequest::Execute() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  const smart_objects::SmartObject* rc_capabilities =
+      hmi_capabilities_.rc_capability();
+
+  const std::string module_type = ModuleType();
+  if (rc_capabilities &&
+      !CheckIfModuleTypeExistInCapabilities(*rc_capabilities, module_type)) {
+    LOG4CXX_WARN(logger_, "Accessing not supported module data");
+    SetResourceState(ModuleType(), ResourceState::FREE);
+    SendResponse(false,
+                 mobile_apis::Result::UNSUPPORTED_RESOURCE,
+                 "Accessing not supported module data");
+    return;
+  }
+
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(connection_key());
+
+  if (HasRequestExcessiveSubscription()) {
+    excessive_subscription_occured_ = true;
+    is_subscribed =
+        (*message_)[app_mngr::strings::msg_params][message_params::kSubscribe]
+            .asBool();
+    RemoveExcessiveSubscription();
+  }
+
+  (*message_)[app_mngr::strings::msg_params][app_mngr::strings::app_id] =
+      app->app_id();
+
+  SendHMIRequest(hmi_apis::FunctionID::RC_GetInteriorVehicleData,
+                 &(*message_)[app_mngr::strings::msg_params],
+                 true);
+}
+
+void GetInteriorVehicleDataRequest::on_event(
+    const app_mngr::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  RCCommandRequest::on_event(event);
+
+  if (hmi_apis::FunctionID::RC_GetInteriorVehicleData != event.id()) {
+    return;
+  }
+
+  smart_objects::SmartObject& hmi_response =
+      const_cast<smart_objects::SmartObject&>(event.smart_object());
+
+  mobile_apis::Result::eType result_code =
+      GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
+          hmi_response[app_mngr::strings::params][app_mngr::hmi_response::code]
+              .asUInt()));
+
+  bool result =
+      helpers::Compare<mobile_apis::Result::eType, helpers::EQ, helpers::ONE>(
+          result_code,
+          mobile_apis::Result::SUCCESS,
+          mobile_apis::Result::WARNINGS);
+
+  if (mobile_apis::Result::READ_ONLY == result_code) {
+    result = false;
+    result_code = mobile_apis::Result::GENERIC_ERROR;
+  }
+
+  if (result) {
+    ProccessSubscription(hmi_response);
+  } else {
+    hmi_response[app_mngr::strings::msg_params].erase(
+        message_params::kIsSubscribed);
+  }
+  std::string response_info;
+  GetInfo(hmi_response, response_info);
+  SetResourceState(ModuleType(), ResourceState::FREE);
+  SendResponse(result,
+               result_code,
+               response_info.c_str(),
+               &hmi_response[app_mngr::strings::msg_params]);
+}
+
+GetInteriorVehicleDataRequest::~GetInteriorVehicleDataRequest() {}
+
+void GetInteriorVehicleDataRequest::ProccessSubscription(
+    const NsSmartDeviceLink::NsSmartObjects::SmartObject& hmi_response) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  const bool is_subscribe_present_in_request =
+      (*message_)[app_mngr::strings::msg_params].keyExists(
+          message_params::kSubscribe) ||
+      excessive_subscription_occured_;
+
+  const bool isSubscribed_present_in_response =
+      hmi_response[app_mngr::strings::msg_params].keyExists(
+          message_params::kIsSubscribed);
+
+  smart_objects::SmartObject& temp_hmi_response =
+      const_cast<smart_objects::SmartObject&>(hmi_response);
+
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  RCAppExtensionPtr extension =
+      resource_allocation_manager_.GetApplicationExtention(app);
+  const char* module_type;
+  NsSmartDeviceLink::NsSmartObjects::
+      EnumConversionHelper<mobile_apis::ModuleType::eType>::EnumToCString(
+          static_cast<mobile_apis::ModuleType::eType>(
+              hmi_response[app_mngr::strings::msg_params]
+                          [message_params::kModuleData]
+                          [message_params::kModuleType].asUInt()),
+          &module_type);
+  if (excessive_subscription_occured_) {
+    is_subscribed = extension->IsSubscibedToInteriorVehicleData(module_type);
+    temp_hmi_response[app_mngr::strings::msg_params]
+                     [message_params::kIsSubscribed] = is_subscribed;
+    return;
+  }
+  if (!is_subscribe_present_in_request && !isSubscribed_present_in_response) {
+    return;
+  }
+
+  if (is_subscribe_present_in_request && !isSubscribed_present_in_response) {
+    LOG4CXX_WARN(logger_,
+                 "conditional mandatory parameter "
+                     << message_params::kIsSubscribed
+                     << " missed in hmi response");
+
+    is_subscribed = extension->IsSubscibedToInteriorVehicleData(module_type);
+    temp_hmi_response[app_mngr::strings::msg_params]
+                     [message_params::kIsSubscribed] = is_subscribed;
+    return;
+  }
+
+  if (!is_subscribe_present_in_request && isSubscribed_present_in_response) {
+    LOG4CXX_WARN(logger_,
+                 "Parameter " << message_params::kIsSubscribed
+                              << " is ignored due to absence '"
+                              << message_params::kSubscribe
+                              << "' parameter in request");
+    smart_objects::SmartObject& temp_hmi_response =
+        const_cast<smart_objects::SmartObject&>(hmi_response);
+    temp_hmi_response[app_mngr::strings::msg_params].erase(
+        message_params::kIsSubscribed);
+    return;
+  }
+
+  const bool request_subscribe =
+      (*message_)[app_mngr::strings::msg_params][message_params::kSubscribe]
+          .asBool();
+  const bool response_subscribe =
+      hmi_response[app_mngr::strings::msg_params][message_params::kIsSubscribed]
+          .asBool();
+  is_subscribed = response_subscribe;
+
+  LOG4CXX_TRACE(logger_, "request_subscribe = " << request_subscribe);
+  LOG4CXX_TRACE(logger_, "response_subscribe = " << response_subscribe);
+  if (request_subscribe == response_subscribe) {
+    const std::string module_type = ModuleType();
+    if (response_subscribe) {
+      LOG4CXX_DEBUG(logger_,
+                    "SubscribeToInteriorVehicleData " << app->app_id() << " "
+                                                      << module_type);
+      extension->SubscribeToInteriorVehicleData(module_type);
+    } else {
+      LOG4CXX_DEBUG(logger_,
+                    "UnsubscribeFromInteriorVehicleData "
+                        << app->app_id() << " " << module_type);
+      extension->UnsubscribeFromInteriorVehicleData(module_type);
+    }
+  }
+}
+
+bool GetInteriorVehicleDataRequest::HasRequestExcessiveSubscription() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const bool is_subscribe_present_in_request =
+      (*message_)[app_mngr::strings::msg_params].keyExists(
+          message_params::kSubscribe);
+
+  if (is_subscribe_present_in_request) {
+    app_mngr::ApplicationSharedPtr app =
+        application_manager_.application(CommandRequestImpl::connection_key());
+    RCAppExtensionPtr extension =
+        resource_allocation_manager_.GetApplicationExtention(app);
+
+    const bool is_app_already_subscribed =
+        extension->IsSubscibedToInteriorVehicleData(ModuleType());
+    const bool app_wants_to_subscribe =
+        (*message_)[app_mngr::strings::msg_params][message_params::kSubscribe]
+            .asBool();
+    if (!app_wants_to_subscribe && !is_app_already_subscribed) {
+      return true;
+    }
+    return app_wants_to_subscribe && is_app_already_subscribed;
+  }
+  return false;
+}
+
+void GetInteriorVehicleDataRequest::RemoveExcessiveSubscription() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  (*message_)[app_mngr::strings::msg_params].erase(message_params::kSubscribe);
+}
+
+std::string GetInteriorVehicleDataRequest::ModuleType() {
+  mobile_apis::ModuleType::eType module_type = static_cast<
+      mobile_apis::ModuleType::eType>(
+      (*message_)[app_mngr::strings::msg_params][message_params::kModuleType]
+          .asUInt());
+  const char* str;
+  const bool ok = NsSmartDeviceLink::NsSmartObjects::EnumConversionHelper<
+      mobile_apis::ModuleType::eType>::EnumToCString(module_type, &str);
+  return ok ? str : "unknown";
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/get_interior_vehicle_data_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/get_interior_vehicle_data_response.cc
new file mode 100644
index 0000000000..18ccc5b497
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/get_interior_vehicle_data_response.cc
@@ -0,0 +1,61 @@
+/*
+ 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 "rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_response.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+GetInteriorVehicleDataResponse::GetInteriorVehicleDataResponse(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::CommandResponseImpl(message,
+                                                         application_manager,
+                                                         rpc_service,
+                                                         hmi_capabilities,
+                                                         policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+GetInteriorVehicleDataResponse::~GetInteriorVehicleDataResponse() {}
+
+void GetInteriorVehicleDataResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  application_manager_.GetRPCService().SendMessageToMobile(message_);
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/on_interior_vehicle_data_notification.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/on_interior_vehicle_data_notification.cc
new file mode 100644
index 0000000000..dfe2feb622
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/on_interior_vehicle_data_notification.cc
@@ -0,0 +1,101 @@
+/*
+ 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 copyright holders nor the names of their 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 "rc_rpc_plugin/commands/mobile/on_interior_vehicle_data_notification.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "smart_objects/enum_schema_item.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+OnInteriorVehicleDataNotification::OnInteriorVehicleDataNotification(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler,
+    ResourceAllocationManager& resource_allocation_manager)
+    : app_mngr::commands::CommandNotificationImpl(message,
+                                                  application_manager,
+                                                  rpc_service,
+                                                  hmi_capabilities,
+                                                  policy_handler) {
+  UNUSED(resource_allocation_manager);
+}
+
+OnInteriorVehicleDataNotification::~OnInteriorVehicleDataNotification() {}
+
+void OnInteriorVehicleDataNotification::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  const std::string module_type = ModuleType();
+
+  typedef std::vector<application_manager::ApplicationSharedPtr> AppPtrs;
+  AppPtrs apps = RCRPCPlugin::GetRCApplications(application_manager_);
+
+  for (AppPtrs::iterator it = apps.begin(); it != apps.end(); ++it) {
+    DCHECK(*it);
+    application_manager::Application& app = **it;
+
+    RCAppExtensionPtr extension =
+        application_manager::AppExtensionPtr::static_pointer_cast<
+            RCAppExtension>(app.QueryInterface(RCRPCPlugin::kRCPluginID));
+    DCHECK(extension);
+    LOG4CXX_TRACE(logger_,
+                  "Check subscription for "
+                      << app.app_id() << "and module type " << module_type);
+    if (extension->IsSubscibedToInteriorVehicleData(module_type)) {
+      (*message_)[app_mngr::strings::params]
+                 [app_mngr::strings::connection_key] = app.app_id();
+      SendNotification();
+    }
+  }
+}
+
+std::string OnInteriorVehicleDataNotification::ModuleType() {
+  mobile_apis::ModuleType::eType module_type =
+      static_cast<mobile_apis::ModuleType::eType>(
+          (*message_)[app_mngr::strings::msg_params]
+                     [message_params::kModuleData][message_params::kModuleType]
+                         .asUInt());
+  const char* str;
+  const bool ok = NsSmartDeviceLink::NsSmartObjects::EnumConversionHelper<
+      mobile_apis::ModuleType::eType>::EnumToCString(module_type, &str);
+  return ok ? str : "unknown";
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc
new file mode 100644
index 0000000000..160915f347
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_request.cc
@@ -0,0 +1,365 @@
+/*
+ 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 "rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "smart_objects/enum_schema_item.h"
+#include "utils/macro.h"
+#include "json/json.h"
+#include "utils/helpers.h"
+#include "interfaces/MOBILE_API.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+using namespace json_keys;
+using namespace message_params;
+
+namespace {
+std::vector<std::string> GetModuleReadOnlyParams(
+    const std::string& module_type) {
+  std::vector<std::string> module_ro_params;
+  if (enums_value::kClimate == module_type) {
+    module_ro_params.push_back(kCurrentTemperature);
+  } else if (enums_value::kRadio == module_type) {
+    module_ro_params.push_back(kRdsData);
+    module_ro_params.push_back(kAvailableHDs);
+    module_ro_params.push_back(kSignalStrength);
+    module_ro_params.push_back(kSignalChangeThreshold);
+    module_ro_params.push_back(kState);
+  }
+  return module_ro_params;
+}
+
+const std::map<std::string, std::string> GetModuleDataToCapabilitiesMapping() {
+  std::map<std::string, std::string> mapping;
+  // climate
+  mapping["fanSpeed"] = "fanSpeedAvailable";
+  mapping["currentTemperature"] = "currentTemperatureAvailable";
+  mapping["desiredTemperature"] = "desiredTemperatureAvailable";
+  mapping["acEnable"] = "acEnableAvailable";
+  mapping["circulateAirEnable"] = "circulateAirEnableAvailable";
+  mapping["autoModeEnable"] = "autoModeEnableAvailable";
+  mapping["defrostZone"] = "defrostZoneAvailable";
+  mapping["dualModeEnable"] = "dualModeEnableAvailable";
+  mapping["acMaxEnable"] = "acMaxEnableAvailable";
+  mapping["ventilationMode"] = "ventilationModeAvailable";
+
+  // radio
+  mapping["band"] = "radioBandAvailable";
+  mapping["frequencyInteger"] = "radioFrequencyAvailable";
+  mapping["frequencyFraction"] = "radioFrequencyAvailable";
+  mapping["rdsData"] = "rdsDataAvailable";
+  mapping["availableHDs"] = "availableHDsAvailable";
+  mapping["hdChannel"] = "availableHDsAvailable";
+  mapping["signalStrength"] = "signalStrengthAvailable";
+  mapping["signalChangeThreshold"] = "signalChangeThresholdAvailable";
+  mapping["radioEnable"] = "radioEnableAvailable";
+  mapping["state"] = "stateAvailable";
+
+  return mapping;
+}
+}  // namespace
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+SetInteriorVehicleDataRequest::SetInteriorVehicleDataRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : RCCommandRequest(message,
+                       application_manager,
+                       rpc_service,
+                       hmi_capabilities,
+                       policy_handle,
+                       resource_allocation_manager) {}
+
+SetInteriorVehicleDataRequest::~SetInteriorVehicleDataRequest() {}
+
+bool CheckControlDataByCapabilities(
+    const smart_objects::SmartObject& module_caps,
+    const smart_objects::SmartObject& control_data) {
+  std::map<std::string, std::string> mapping =
+      GetModuleDataToCapabilitiesMapping();
+
+  auto it = control_data.map_begin();
+  for (; it != control_data.map_end(); ++it) {
+    const std::string& request_parameter = it->first;
+    const std::string& caps_key = mapping[request_parameter];
+    const smart_objects::SmartObject& capabilities_status = module_caps[0];
+    LOG4CXX_DEBUG(logger_,
+                  "Checking request parameter "
+                      << request_parameter
+                      << " with capabilities. Appropriate key is " << caps_key);
+    if (!capabilities_status.keyExists(caps_key)) {
+      LOG4CXX_DEBUG(logger_,
+                    "Capability "
+                        << caps_key
+                        << " is missed in RemoteControl capabilities");
+      return false;
+    }
+    if (!capabilities_status[caps_key].asBool()) {
+      LOG4CXX_DEBUG(logger_,
+                    "Capability "
+                        << caps_key
+                        << " is switched off in RemoteControl capabilities");
+      return false;
+    }
+  }
+  return true;
+}
+
+bool CheckIfModuleDataExistInCapabilities(
+    const smart_objects::SmartObject& rc_capabilities,
+    const smart_objects::SmartObject& module_data) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  bool is_radio_data_valid = true;
+  bool is_climate_data_valid = true;
+  if (module_data.keyExists(message_params::kRadioControlData)) {
+    if (!rc_capabilities.keyExists(strings::kradioControlCapabilities)) {
+      LOG4CXX_DEBUG(logger_, " Radio control capabilities not present");
+      return false;
+    }
+    const smart_objects::SmartObject& radio_caps =
+        rc_capabilities[strings::kradioControlCapabilities];
+    is_radio_data_valid = CheckControlDataByCapabilities(
+        radio_caps, module_data[strings::kRadioControlData]);
+  }
+  if (module_data.keyExists(message_params::kClimateControlData)) {
+    if (!rc_capabilities.keyExists(strings::kclimateControlCapabilities)) {
+      LOG4CXX_DEBUG(logger_, " Climate control capabilities not present");
+      return false;
+    }
+    const smart_objects::SmartObject& climate_caps =
+        rc_capabilities[strings::kclimateControlCapabilities];
+    is_climate_data_valid = CheckControlDataByCapabilities(
+        climate_caps, module_data[strings::kClimateControlData]);
+  }
+
+  return is_radio_data_valid && is_climate_data_valid;
+}
+
+void SetInteriorVehicleDataRequest::Execute() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  smart_objects::SmartObject& module_data =
+      (*message_)[app_mngr::strings::msg_params][message_params::kModuleData];
+  const std::string module_type = ModuleType();
+  bool module_type_and_data_match = true;
+
+  if (enums_value::kRadio == module_type) {
+    module_type_and_data_match =
+        !(module_data.keyExists(message_params::kClimateControlData));
+  }
+
+  if (enums_value::kClimate == module_type) {
+    module_type_and_data_match =
+        !(module_data.keyExists(message_params::kRadioControlData));
+  }
+
+  if (module_type_and_data_match) {
+    const smart_objects::SmartObject* rc_capabilities =
+        hmi_capabilities_.rc_capability();
+    if (rc_capabilities &&
+        !CheckIfModuleDataExistInCapabilities(*rc_capabilities, module_data)) {
+      LOG4CXX_WARN(logger_, "Accessing not supported module data");
+      SetResourceState(ModuleType(), ResourceState::FREE);
+      SendResponse(false,
+                   mobile_apis::Result::UNSUPPORTED_RESOURCE,
+                   "Accessing not supported module data");
+      return;
+    }
+    if (AreAllParamsReadOnly(module_data)) {
+      LOG4CXX_WARN(logger_, "All request params in module type are READ ONLY!");
+      SetResourceState(ModuleType(), ResourceState::FREE);
+      SendResponse(false,
+                   mobile_apis::Result::READ_ONLY,
+                   "All request params in module type are READ ONLY!");
+      return;
+    }
+    if (AreReadOnlyParamsPresent(module_data)) {
+      LOG4CXX_DEBUG(logger_, "Request module type has READ ONLY parameters");
+      LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameters... ");
+      CutOffReadOnlyParams(module_data);
+    }
+    application_manager_.RemoveHMIFakeParameters(message_);
+
+    app_mngr::ApplicationSharedPtr app =
+        application_manager_.application(connection_key());
+    (*message_)[app_mngr::strings::msg_params][app_mngr::strings::app_id] =
+        app->app_id();
+
+    SendHMIRequest(hmi_apis::FunctionID::RC_SetInteriorVehicleData,
+                   &(*message_)[app_mngr::strings::msg_params],
+                   true);
+  } else {
+    LOG4CXX_WARN(logger_, "Request module type & data mismatch!");
+    SendResponse(false,
+                 mobile_apis::Result::INVALID_DATA,
+                 "Request module type & data mismatch!");
+  }
+}
+
+void SetInteriorVehicleDataRequest::on_event(
+    const app_mngr::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  RCCommandRequest::on_event(event);
+
+  if (hmi_apis::FunctionID::RC_SetInteriorVehicleData != event.id()) {
+    return;
+  }
+
+  const smart_objects::SmartObject& hmi_response = event.smart_object();
+  mobile_apis::Result::eType result_code =
+      GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
+          hmi_response[app_mngr::strings::params][app_mngr::hmi_response::code]
+              .asUInt()));
+
+  bool result =
+      helpers::Compare<mobile_apis::Result::eType, helpers::EQ, helpers::ONE>(
+          result_code,
+          mobile_apis::Result::SUCCESS,
+          mobile_apis::Result::WARNINGS);
+
+  smart_objects::SmartObject response_params;
+  if (result) {
+    response_params = hmi_response[app_mngr::strings::msg_params];
+  }
+  std::string info;
+  GetInfo(hmi_response, info);
+  SendResponse(
+      result, result_code, info.c_str(), result ? &response_params : nullptr);
+}
+
+const smart_objects::SmartObject& SetInteriorVehicleDataRequest::ControlData(
+    const smart_objects::SmartObject& module_data) {
+  const std::string module = ModuleType();
+
+  if (enums_value::kRadio == module) {
+    return module_data[message_params::kRadioControlData];
+  } else {
+    return module_data[message_params::kClimateControlData];
+  }
+}
+
+bool SetInteriorVehicleDataRequest::AreAllParamsReadOnly(
+    const smart_objects::SmartObject& module_data) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const smart_objects::SmartObject& module_type_params =
+      ControlData(module_data);
+  auto it = module_type_params.map_begin();
+  std::vector<std::string> ro_params = GetModuleReadOnlyParams(ModuleType());
+  for (; it != module_type_params.map_end(); ++it) {
+    if (!helpers::in_range(ro_params, it->first)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SetInteriorVehicleDataRequest::AreReadOnlyParamsPresent(
+    const smart_objects::SmartObject& module_data) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const smart_objects::SmartObject& module_type_params =
+      ControlData(module_data);
+  auto it = module_type_params.map_begin();
+  std::vector<std::string> ro_params = GetModuleReadOnlyParams(ModuleType());
+  for (; it != module_type_params.map_end(); ++it) {
+    if (helpers::in_range(ro_params, it->first)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void SetInteriorVehicleDataRequest::CutOffReadOnlyParams(
+    smart_objects::SmartObject& module_data) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const smart_objects::SmartObject& module_type_params =
+      ControlData(module_data);
+  const std::string module_type = ModuleType();
+  std::vector<std::string> ro_params = GetModuleReadOnlyParams(module_type);
+
+  for (auto& it : ro_params) {
+    if (module_type_params.keyExists(it)) {
+      if (enums_value::kClimate == module_type) {
+        module_data[message_params::kClimateControlData].erase(it);
+        LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it);
+      } else if (enums_value::kRadio == module_type) {
+        module_data[message_params::kRadioControlData].erase(it);
+        LOG4CXX_DEBUG(logger_, "Cutting-off READ ONLY parameter: " << it);
+      }
+    }
+  }
+}
+
+std::string SetInteriorVehicleDataRequest::ModuleType() {
+  mobile_apis::ModuleType::eType module_type =
+      static_cast<mobile_apis::ModuleType::eType>(
+          (*message_)[app_mngr::strings::msg_params]
+                     [message_params::kModuleData][message_params::kModuleType]
+                         .asUInt());
+  const char* str;
+  const bool ok = NsSmartDeviceLink::NsSmartObjects::EnumConversionHelper<
+      mobile_apis::ModuleType::eType>::EnumToCString(module_type, &str);
+  return ok ? str : "unknown";
+}
+
+AcquireResult::eType SetInteriorVehicleDataRequest::AcquireResource(
+    const app_mngr::commands::MessageSharedPtr& message) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const std::string module_type = ModuleType();
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  return resource_allocation_manager_.AcquireResource(module_type,
+                                                      app->app_id());
+}
+
+bool SetInteriorVehicleDataRequest::IsResourceFree(
+    const std::string& module_type) const {
+  return resource_allocation_manager_.IsResourceFree(module_type);
+}
+
+void SetInteriorVehicleDataRequest::SetResourceState(
+    const std::string& module_type, const ResourceState::eType state) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  resource_allocation_manager_.SetResourceState(
+      module_type, app->app_id(), state);
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_response.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_response.cc
new file mode 100644
index 0000000000..2d5d0350e1
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/mobile/set_interior_vehicle_data_response.cc
@@ -0,0 +1,29 @@
+#include "rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_response.h"
+#include "utils/macro.h"
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+SetInteriorVehicleDataResponse::SetInteriorVehicleDataResponse(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::CommandResponseImpl(message,
+                                                         application_manager,
+                                                         rpc_service,
+                                                         hmi_capabilities,
+                                                         policy_handle) {
+  UNUSED(resource_allocation_manager);
+}
+SetInteriorVehicleDataResponse::~SetInteriorVehicleDataResponse() {}
+
+void SetInteriorVehicleDataResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  application_manager_.GetRPCService().SendMessageToMobile(message_);
+}
+
+}  // namespace commands
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/rc_command_request.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/rc_command_request.cc
new file mode 100644
index 0000000000..4f968dd2d8
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/commands/rc_command_request.cc
@@ -0,0 +1,265 @@
+/*
+ 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 "rc_rpc_plugin/commands/rc_command_request.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "application_manager/message_helper.h"
+#include "application_manager/hmi_interfaces.h"
+#include "smart_objects/enum_schema_item.h"
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+namespace rc_rpc_plugin {
+namespace commands {
+
+RCCommandRequest::RCCommandRequest(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::ApplicationManager& application_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handle,
+    rc_rpc_plugin::ResourceAllocationManager& resource_allocation_manager)
+    : application_manager::commands::CommandRequestImpl(message,
+                                                        application_manager,
+                                                        rpc_service,
+                                                        hmi_capabilities,
+                                                        policy_handle)
+    , is_subscribed(false)
+    , resource_allocation_manager_(resource_allocation_manager) {}
+
+RCCommandRequest::~RCCommandRequest() {}
+
+bool RCCommandRequest::IsInterfaceAvailable(
+    const app_mngr::HmiInterfaces::InterfaceID interface) const {
+  app_mngr::HmiInterfaces& hmi_interfaces =
+      application_manager_.hmi_interfaces();
+  const app_mngr::HmiInterfaces::InterfaceState state =
+      hmi_interfaces.GetInterfaceState(interface);
+  return app_mngr::HmiInterfaces::STATE_NOT_AVAILABLE != state;
+}
+
+void RCCommandRequest::onTimeOut() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const std::string module_type = ModuleType();
+  SetResourceState(module_type, ResourceState::FREE);
+  SendResponse(
+      false, mobile_apis::Result::GENERIC_ERROR, "Request timeout expired");
+}
+
+bool RCCommandRequest::CheckDriverConsent() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  RCAppExtensionPtr extension =
+      resource_allocation_manager_.GetApplicationExtention(app);
+  if (!extension) {
+    LOG4CXX_ERROR(logger_, "NULL pointer.");
+    return false;
+  }
+
+  const std::string module_type = ModuleType();
+  rc_rpc_plugin::TypeAccess access = CheckModule(module_type, app);
+
+  if (rc_rpc_plugin::kAllowed == access) {
+    set_auto_allowed(true);
+    return true;
+  }
+  SendDisallowed(access);
+  return false;
+}
+
+rc_rpc_plugin::TypeAccess RCCommandRequest::CheckModule(
+    const std::string& module_type,
+    application_manager::ApplicationSharedPtr app) {
+  return policy_handler_.CheckModule(app->policy_app_id(), module_type)
+             ? rc_rpc_plugin::TypeAccess::kAllowed
+             : rc_rpc_plugin::TypeAccess::kDisallowed;
+}
+
+void RCCommandRequest::SendDisallowed(rc_rpc_plugin::TypeAccess access) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  std::string info;
+  if (rc_rpc_plugin::kDisallowed == access) {
+    info = disallowed_info_.empty()
+               ? "The RPC is disallowed by vehicle settings"
+               : disallowed_info_;
+  } else {
+    return;
+  }
+  LOG4CXX_ERROR(logger_, info);
+  SendResponse(false, mobile_apis::Result::DISALLOWED, info.c_str());
+}
+
+void RCCommandRequest::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+
+  if (!IsInterfaceAvailable(app_mngr::HmiInterfaces::HMI_INTERFACE_RC)) {
+    LOG4CXX_WARN(logger_, "HMI interface RC is not available");
+    SendResponse(false,
+                 mobile_apis::Result::UNSUPPORTED_RESOURCE,
+                 "Remote control is not supported by system");
+    return;
+  }
+  LOG4CXX_TRACE(logger_, "RC interface is available!");
+  if (!policy_handler_.CheckHMIType(
+          app->policy_app_id(),
+          mobile_apis::AppHMIType::eType::REMOTE_CONTROL,
+          app->app_types())) {
+    LOG4CXX_WARN(logger_, "Application has no remote control functions");
+    SendResponse(false, mobile_apis::Result::DISALLOWED, "");
+    return;
+  }
+
+  if (CheckDriverConsent()) {
+    if (AcquireResources()) {
+      Execute();  // run child's logic
+    }
+    // If resource is not aqcuired, AcquireResources method will either
+    // send response to mobile or
+    // send additional request to HMI to ask driver consent
+  }
+}
+
+bool RCCommandRequest::AcquireResources() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const std::string module_type = ModuleType();
+
+  if (!IsResourceFree(module_type)) {
+    LOG4CXX_WARN(logger_, "Resource is busy.");
+    SendResponse(false, mobile_apis::Result::IN_USE, "");
+    return false;
+  }
+
+  AcquireResult::eType acquire_result = AcquireResource(message_);
+  switch (acquire_result) {
+    case AcquireResult::ALLOWED: {
+      SetResourceState(module_type, ResourceState::BUSY);
+      return true;
+    }
+    case AcquireResult::IN_USE: {
+      SendResponse(false, mobile_apis::Result::IN_USE, "");
+      return false;
+    }
+    case AcquireResult::ASK_DRIVER: {
+      SendGetUserConsent(module_type);
+      return false;
+    }
+    case AcquireResult::REJECTED: {
+      SendResponse(false, mobile_apis::Result::REJECTED, "");
+      return false;
+    }
+  }
+  return false;
+}
+
+void RCCommandRequest::on_event(const app_mngr::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  if (event.id() == hmi_apis::FunctionID::RC_GetInteriorVehicleDataConsent) {
+    ProcessAccessResponse(event);
+  } else {
+    const std::string module_type = ModuleType();
+    SetResourceState(module_type, ResourceState::FREE);
+  }
+}
+
+void RCCommandRequest::ProcessAccessResponse(
+    const app_mngr::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  const std::string module_type = ModuleType();
+  if (!app) {
+    LOG4CXX_ERROR(logger_, "NULL pointer.");
+    SendResponse(false, mobile_apis::Result::APPLICATION_NOT_REGISTERED, "");
+    return;
+  }
+
+  const smart_objects::SmartObject& message = event.smart_object();
+
+  mobile_apis::Result::eType result_code =
+      GetMobileResultCode(static_cast<hmi_apis::Common_Result::eType>(
+          message[app_mngr::strings::params][app_mngr::hmi_response::code]
+              .asUInt()));
+
+  const bool result =
+      helpers::Compare<mobile_apis::Result::eType, helpers::EQ, helpers::ONE>(
+          result_code,
+          mobile_apis::Result::SUCCESS,
+          mobile_apis::Result::WARNINGS);
+
+  bool is_allowed = false;
+  if (result) {
+    if (message[app_mngr::strings::msg_params].keyExists(
+            message_params::kAllowed)) {
+      is_allowed =
+          message[app_mngr::strings::msg_params][message_params::kAllowed]
+              .asBool();
+    }
+    if (is_allowed) {
+      resource_allocation_manager_.ForceAcquireResource(module_type,
+                                                        app->app_id());
+      SetResourceState(module_type, ResourceState::BUSY);
+      Execute();  // run child's logic
+    } else {
+      resource_allocation_manager_.OnDriverDisallowed(module_type,
+                                                      app->app_id());
+      SendResponse(
+          false,
+          mobile_apis::Result::REJECTED,
+          "The resource is in use and the driver disallows this remote "
+          "control RPC");
+    }
+  } else {
+    std::string response_info;
+    GetInfo(message, response_info);
+    SendResponse(false, result_code, response_info.c_str());
+  }
+}
+
+void RCCommandRequest::SendGetUserConsent(const std::string& module_type) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  app_mngr::ApplicationSharedPtr app =
+      application_manager_.application(CommandRequestImpl::connection_key());
+  DCHECK(app);
+  smart_objects::SmartObject msg_params =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
+  msg_params[app_mngr::strings::app_id] = app->app_id();
+  msg_params[message_params::kModuleType] = module_type;
+  SendHMIRequest(hmi_apis::FunctionID::RC_GetInteriorVehicleDataConsent,
+                 &msg_params,
+                 true);
+}
+}
+}
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_app_extension.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_app_extension.cc
new file mode 100644
index 0000000000..5c0a94cccc
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_app_extension.cc
@@ -0,0 +1,68 @@
+/*
+ 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 "rc_rpc_plugin/rc_app_extension.h"
+
+namespace rc_rpc_plugin {
+RCAppExtension::RCAppExtension(application_manager::AppExtensionUID uid)
+    : AppExtension(uid) {}
+
+void RCAppExtension::SubscribeToInteriorVehicleData(
+    const std::string& module_type) {
+  subscribed_interior_vehicle_data_.insert(module_type);
+}
+
+void RCAppExtension::UnsubscribeFromInteriorVehicleData(
+    const std::string& module_type) {
+  subscribed_interior_vehicle_data_.erase(module_type);
+}
+
+void RCAppExtension::UnsubscribeFromInteriorVehicleData() {
+  subscribed_interior_vehicle_data_.clear();
+}
+
+bool RCAppExtension::IsSubscibedToInteriorVehicleData(
+    const std::string& module_type) {
+  std::set<std::string>::iterator it =
+      subscribed_interior_vehicle_data_.find(module_type);
+
+  return (it != subscribed_interior_vehicle_data_.end());
+}
+
+void RCAppExtension::SaveResumptionData(
+    NsSmartDeviceLink::NsSmartObjects::SmartObject& resumption_data) {}
+
+void RCAppExtension::ProcessResumption(
+    const NsSmartDeviceLink::NsSmartObjects::SmartObject& resumption_data) {}
+
+RCAppExtension::~RCAppExtension() {}
+}  //  namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_command_factory.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_command_factory.cc
new file mode 100644
index 0000000000..707d35aa0f
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_command_factory.cc
@@ -0,0 +1,306 @@
+/*
+ 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 copyright holders nor the names of their 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 "rc_rpc_plugin/rc_command_factory.h"
+#include "rc_rpc_plugin/commands/mobile/button_press_request.h"
+#include "rc_rpc_plugin/commands/mobile/button_press_response.h"
+#include "rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_response.h"
+#include "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_request.h"
+#include "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_response.h"
+#include "rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_response.h"
+#include "rc_rpc_plugin/commands/mobile/on_interior_vehicle_data_notification.h"
+#include "rc_rpc_plugin/commands/hmi/rc_button_press_request.h"
+#include "rc_rpc_plugin/commands/hmi/rc_button_press_response.h"
+#include "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_response.h"
+#include "rc_rpc_plugin/commands/hmi/rc_on_interior_vehicle_data_notification.h"
+#include "rc_rpc_plugin/commands/hmi/rc_on_remote_control_settings_notification.h"
+#include "rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/commands/hmi/rc_set_interior_vehicle_data_response.h"
+
+#include "interfaces/MOBILE_API.h"
+#include "interfaces/HMI_API.h"
+
+#include "rc_rpc_plugin/resource_allocation_manager.h"
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+namespace application_manager {
+using rc_rpc_plugin::ResourceAllocationManager;
+
+template <typename RCCommandType>
+class RCCommandCreator : public CommandCreator {
+ public:
+  RCCommandCreator(ApplicationManager& application_manager,
+                   rpc_service::RPCService& rpc_service,
+                   HMICapabilities& hmi_capabilities,
+                   PolicyHandlerInterface& policy_handler,
+                   ResourceAllocationManager& resource_allocation_manager)
+      : application_manager_(application_manager)
+      , rpc_service_(rpc_service)
+      , hmi_capabilities_(hmi_capabilities)
+      , policy_handler_(policy_handler)
+      , resource_allocation_manager_(resource_allocation_manager) {}
+
+ private:
+  bool CanBeCreated() const override {
+    return true;
+  }
+
+  CommandSharedPtr create(
+      const commands::MessageSharedPtr& message) const override {
+    CommandSharedPtr command(new RCCommandType(message,
+                                               application_manager_,
+                                               rpc_service_,
+                                               hmi_capabilities_,
+                                               policy_handler_,
+                                               resource_allocation_manager_));
+    return command;
+  }
+
+  ApplicationManager& application_manager_;
+  RPCService& rpc_service_;
+  HMICapabilities& hmi_capabilities_;
+  PolicyHandlerInterface& policy_handler_;
+  ResourceAllocationManager& resource_allocation_manager_;
+};
+
+struct RCInvalidCommand {};
+
+template <>
+class RCCommandCreator<RCInvalidCommand> : public CommandCreator {
+ public:
+  RCCommandCreator(ApplicationManager& application_manager,
+                   RPCService& rpc_service,
+                   HMICapabilities& hmi_capabilities,
+                   PolicyHandlerInterface& policy_handler,
+                   ResourceAllocationManager& resource_allocation_manager) {
+    UNUSED(application_manager);
+    UNUSED(rpc_service);
+    UNUSED(hmi_capabilities);
+    UNUSED(policy_handler);
+    UNUSED(resource_allocation_manager);
+  }
+
+ private:
+  bool CanBeCreated() const override {
+    return false;
+  }
+
+  CommandSharedPtr create(
+      const commands::MessageSharedPtr& message) const override {
+    UNUSED(message);
+    return CommandSharedPtr();
+  }
+};
+
+struct RCCommandCreatorFactory {
+  RCCommandCreatorFactory(
+      ApplicationManager& application_manager,
+      rpc_service::RPCService& rpc_service,
+      HMICapabilities& hmi_capabilities,
+      PolicyHandlerInterface& policy_handler,
+      ResourceAllocationManager& resource_allocation_manager)
+      : application_manager_(application_manager)
+      , rpc_service_(rpc_service)
+      , hmi_capabilities_(hmi_capabilities)
+      , policy_handler_(policy_handler)
+      , resource_allocation_manager_(resource_allocation_manager) {}
+
+  template <typename RCCommandType>
+  CommandCreator& GetCreator() {
+    static RCCommandCreator<RCCommandType> res(application_manager_,
+                                               rpc_service_,
+                                               hmi_capabilities_,
+                                               policy_handler_,
+                                               resource_allocation_manager_);
+    return res;
+  }
+  ApplicationManager& application_manager_;
+  RPCService& rpc_service_;
+  HMICapabilities& hmi_capabilities_;
+  PolicyHandlerInterface& policy_handler_;
+  ResourceAllocationManager& resource_allocation_manager_;
+};
+}
+
+namespace rc_rpc_plugin {
+using namespace application_manager;
+
+RCCommandFactory::RCCommandFactory(
+    app_mngr::ApplicationManager& app_manager,
+    app_mngr::rpc_service::RPCService& rpc_service,
+    app_mngr::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler,
+    ResourceAllocationManager& allocation_manager)
+    : app_manager_(app_manager)
+    , rpc_service_(rpc_service)
+    , hmi_capabilities_(hmi_capabilities)
+    , policy_handler_(policy_handler)
+    , allocation_manager_(allocation_manager) {}
+
+CommandSharedPtr RCCommandFactory::CreateCommand(
+    const app_mngr::commands::MessageSharedPtr& message,
+    app_mngr::commands::Command::CommandSource source) {
+  if (app_mngr::commands::Command::SOURCE_HMI == source) {
+    hmi_apis::messageType::eType message_type =
+        static_cast<hmi_apis::messageType::eType>(
+            (*message)[strings::params][strings::message_type].asInt());
+
+    hmi_apis::FunctionID::eType function_id =
+        static_cast<hmi_apis::FunctionID::eType>(
+            (*message)[strings::params][strings::function_id].asInt());
+
+    return get_hmi_creator_factory(function_id, message_type).create(message);
+  } else {
+    mobile_apis::messageType::eType message_type =
+        static_cast<mobile_apis::messageType::eType>(
+            (*message)[strings::params][strings::message_type].asInt());
+
+    mobile_apis::FunctionID::eType function_id =
+        static_cast<mobile_apis::FunctionID::eType>(
+            (*message)[strings::params][strings::function_id].asInt());
+
+    return get_mobile_creator_factory(function_id, message_type)
+        .create(message);
+  }
+}
+
+bool RCCommandFactory::IsAbleToProcess(
+    const int32_t function_id,
+    const application_manager::commands::Command::CommandSource message_source)
+    const {
+  using app_mngr::commands::Command;
+  if (Command::SOURCE_HMI == message_source) {
+    return get_hmi_creator_factory(
+               static_cast<hmi_apis::FunctionID::eType>(function_id),
+               hmi_apis::messageType::INVALID_ENUM).CanBeCreated();
+  } else {
+    return get_mobile_creator_factory(
+               static_cast<mobile_api::FunctionID::eType>(function_id),
+               mobile_api::messageType::INVALID_ENUM).CanBeCreated();
+  }
+}
+
+CommandCreator& RCCommandFactory::get_mobile_creator_factory(
+    mobile_api::FunctionID::eType id,
+    mobile_api::messageType::eType message_type) const {
+  LOG4CXX_DEBUG(logger_,
+                "CreateMobileCommand function_id: " << id << " message_type: "
+                                                    << message_type);
+  RCCommandCreatorFactory rc_factory(app_manager_,
+                                     rpc_service_,
+                                     hmi_capabilities_,
+                                     policy_handler_,
+                                     allocation_manager_);
+
+  switch (id) {
+    case mobile_apis::FunctionID::ButtonPressID: {
+      return mobile_api::messageType::request == message_type
+                 ? rc_factory.GetCreator<commands::ButtonPressRequest>()
+                 : rc_factory.GetCreator<commands::ButtonPressResponse>();
+    }
+    case mobile_apis::FunctionID::GetInteriorVehicleDataID: {
+      return mobile_api::messageType::request == message_type
+                 ? rc_factory
+                       .GetCreator<commands::GetInteriorVehicleDataRequest>()
+                 : rc_factory
+                       .GetCreator<commands::GetInteriorVehicleDataResponse>();
+    }
+    case mobile_apis::FunctionID::SetInteriorVehicleDataID: {
+      return mobile_api::messageType::request == message_type
+                 ? rc_factory
+                       .GetCreator<commands::SetInteriorVehicleDataRequest>()
+                 : rc_factory
+                       .GetCreator<commands::SetInteriorVehicleDataResponse>();
+    }
+    case mobile_apis::FunctionID::OnInteriorVehicleDataID: {
+      return rc_factory
+          .GetCreator<commands::OnInteriorVehicleDataNotification>();
+    }
+    default: { return rc_factory.GetCreator<RCInvalidCommand>(); }
+  }
+}
+
+CommandCreator& RCCommandFactory::get_hmi_creator_factory(
+    hmi_apis::FunctionID::eType id,
+    hmi_apis::messageType::eType message_type) const {
+  LOG4CXX_DEBUG(logger_,
+                "CreateHMICommand function_id: " << id << " message_type: "
+                                                 << message_type);
+
+  RCCommandCreatorFactory rc_factory(app_manager_,
+                                     rpc_service_,
+                                     hmi_capabilities_,
+                                     policy_handler_,
+                                     allocation_manager_);
+
+  switch (id) {
+    case hmi_apis::FunctionID::Buttons_ButtonPress: {
+      return hmi_apis::messageType::request == message_type
+                 ? rc_factory.GetCreator<commands::RCButtonPressRequest>()
+                 : rc_factory.GetCreator<commands::RCButtonPressResponse>();
+    }
+    case hmi_apis::FunctionID::RC_GetInteriorVehicleData: {
+      return hmi_apis::messageType::request == message_type
+                 ? rc_factory
+                       .GetCreator<commands::RCGetInteriorVehicleDataRequest>()
+                 : rc_factory.GetCreator<
+                       commands::RCGetInteriorVehicleDataResponse>();
+    }
+    case hmi_apis::FunctionID::RC_GetInteriorVehicleDataConsent: {
+      return hmi_apis::messageType::request == message_type
+                 ? rc_factory.GetCreator<
+                       commands::RCGetInteriorVehicleDataConsentRequest>()
+                 : rc_factory.GetCreator<
+                       commands::RCGetInteriorVehicleDataConsentResponse>();
+    }
+    case hmi_apis::FunctionID::RC_SetInteriorVehicleData: {
+      return hmi_apis::messageType::request == message_type
+                 ? rc_factory
+                       .GetCreator<commands::RCSetInteriorVehicleDataRequest>()
+                 : rc_factory.GetCreator<
+                       commands::RCSetInteriorVehicleDataResponse>();
+    }
+    case hmi_apis::FunctionID::RC_OnInteriorVehicleData: {
+      return rc_factory
+          .GetCreator<commands::RCOnInteriorVehicleDataNotification>();
+    }
+    case hmi_apis::FunctionID::RC_OnRemoteControlSettings: {
+      return rc_factory
+          .GetCreator<commands::RCOnRemoteControlSettingsNotification>();
+    }
+    default: { return rc_factory.GetCreator<RCInvalidCommand>(); }
+  }
+}
+}
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_rpc_plugin.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_rpc_plugin.cc
new file mode 100644
index 0000000000..36377c620b
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/rc_rpc_plugin.cc
@@ -0,0 +1,128 @@
+/*
+ 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 copyright holders nor the names of their 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 "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_command_factory.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+#include "rc_rpc_plugin/resource_allocation_manager_impl.h"
+#include "utils/helpers.h"
+
+namespace rc_rpc_plugin {
+namespace plugins = application_manager::plugin_manager;
+
+bool RCRPCPlugin::Init(
+    application_manager::ApplicationManager& app_manager,
+    application_manager::rpc_service::RPCService& rpc_service,
+    application_manager::HMICapabilities& hmi_capabilities,
+    policy::PolicyHandlerInterface& policy_handler) {
+  resource_allocation_manager_.reset(
+      new ResourceAllocationManagerImpl(app_manager, rpc_service));
+  command_factory_.reset(
+      new rc_rpc_plugin::RCCommandFactory(app_manager,
+                                          rpc_service,
+                                          hmi_capabilities,
+                                          policy_handler,
+                                          *resource_allocation_manager_));
+  return true;
+}
+
+bool RCRPCPlugin::IsAbleToProcess(
+    const int32_t function_id,
+    const application_manager::commands::Command::CommandSource
+        message_source) {
+  return command_factory_->IsAbleToProcess(function_id, message_source);
+}
+
+std::string RCRPCPlugin::PluginName() {
+  return "RC RPC Plugin";
+}
+
+application_manager::CommandFactory& RCRPCPlugin::GetCommandFactory() {
+  return *command_factory_;
+}
+
+void RCRPCPlugin::OnPolicyEvent(
+    application_manager::plugin_manager::PolicyEvent event) {
+  switch (event) {
+    case plugins::kApplicationPolicyUpdated: {
+      resource_allocation_manager_->OnPolicyEvent(event);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void RCRPCPlugin::OnApplicationEvent(
+    application_manager::plugin_manager::ApplicationEvent event,
+    application_manager::ApplicationSharedPtr application) {
+  if (!application->is_remote_control_supported()) {
+    return;
+  }
+  switch (event) {
+    case plugins::kApplicationRegistered: {
+      application->AddExtension(new RCAppExtension(kRCPluginID));
+      break;
+    }
+    case plugins::kApplicationExit: {
+      resource_allocation_manager_->OnApplicationEvent(event, application);
+      break;
+    }
+    case plugins::kApplicationUnregistered: {
+      resource_allocation_manager_->OnApplicationEvent(event, application);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+RCRPCPlugin::Apps RCRPCPlugin::GetRCApplications(
+    application_manager::ApplicationManager& app_mngr) {
+  using application_manager::ApplicationSharedPtr;
+  using application_manager::ApplicationSet;
+  ApplicationSet accessor = app_mngr.applications().GetData();
+
+  std::vector<ApplicationSharedPtr> result;
+  for (const auto& it : accessor) {
+    if (it->is_remote_control_supported()) {
+      result.push_back(it);
+    }
+  }
+  return result;
+}
+
+}  // namespace rc_rpc_plugin
+
+extern "C" application_manager::plugin_manager::RPCPlugin* Create() {
+  return new rc_rpc_plugin::RCRPCPlugin();
+}
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/resource_allocation_manager_impl.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/resource_allocation_manager_impl.cc
new file mode 100644
index 0000000000..c2962863e3
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/src/resource_allocation_manager_impl.cc
@@ -0,0 +1,417 @@
+/*
+ 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 copyright holders nor the names of their 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 "rc_rpc_plugin/resource_allocation_manager_impl.h"
+#include "application_manager/application.h"
+#include "application_manager/application_manager.h"
+#include "interfaces/HMI_API.h"
+#include "interfaces/MOBILE_API.h"
+#include "smart_objects/enum_schema_item.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "application_manager/message_helper.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "json/json.h"
+#include "utils/helpers.h"
+#include "utils/make_shared.h"
+
+namespace rc_rpc_plugin {
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "RemoteControlModule")
+
+ResourceAllocationManagerImpl::ResourceAllocationManagerImpl(
+    application_manager::ApplicationManager& app_mngr,
+    application_manager::rpc_service::RPCService& rpc_service)
+    : current_access_mode_(hmi_apis::Common_RCAccessMode::AUTO_ALLOW)
+    , app_mngr_(app_mngr)
+    , rpc_service_(rpc_service) {}
+
+ResourceAllocationManagerImpl::~ResourceAllocationManagerImpl() {}
+
+AcquireResult::eType ResourceAllocationManagerImpl::AcquireResource(
+    const std::string& module_type, const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const application_manager::ApplicationSharedPtr acquiring_app =
+      app_mngr_.application(app_id);
+  if (!acquiring_app) {
+    LOG4CXX_WARN(logger_, "App with app_id: " << app_id << "does not exist!");
+    return AcquireResult::IN_USE;
+  }
+
+  sync_primitives::AutoLock lock(allocated_resources_lock_);
+  const AllocatedResources::const_iterator allocated_it =
+      allocated_resources_.find(module_type);
+  if (allocated_resources_.end() == allocated_it) {
+    SetResourceAquired(module_type, app_id);
+    LOG4CXX_DEBUG(logger_,
+                  "Resource is not acquired yet. "
+                      << "App: " << app_id << " is allowed to acquire "
+                      << module_type);
+    return AcquireResult::ALLOWED;
+  }
+
+  if (app_id == allocated_resources_[module_type]) {
+    LOG4CXX_DEBUG(logger_,
+                  "App: " << app_id << " is already acquired resource "
+                          << module_type);
+    return AcquireResult::ALLOWED;
+  }
+
+  if (IsModuleTypeRejected(module_type, app_id)) {
+    LOG4CXX_DEBUG(logger_,
+                  "Driver disallowed app: " << app_id << " to acquire "
+                                            << module_type);
+    return AcquireResult::REJECTED;
+  }
+
+  const mobile_apis::HMILevel::eType acquiring_app_hmi_level =
+      acquiring_app->hmi_level();
+
+  if (mobile_apis::HMILevel::HMI_FULL != acquiring_app_hmi_level) {
+    LOG4CXX_DEBUG(logger_,
+                  "Aquiring resources is not allowed in HMI level: "
+                      << acquiring_app_hmi_level << ". App: " << app_id
+                      << " is disallowed to acquire " << module_type);
+    return AcquireResult::REJECTED;
+  }
+
+  switch (current_access_mode_) {
+    case hmi_apis::Common_RCAccessMode::AUTO_DENY: {
+      LOG4CXX_DEBUG(logger_,
+                    "Current access_mode is AUTO_DENY. "
+                        << "App: " << app_id << " is disallowed to acquire "
+                        << module_type);
+      return AcquireResult::IN_USE;
+    }
+    case hmi_apis::Common_RCAccessMode::ASK_DRIVER: {
+      LOG4CXX_DEBUG(logger_,
+                    "Current access_mode is ASK_DRIVER. "
+                    "Driver confirmation is required for app: "
+                        << app_id << " to acquire " << module_type);
+      return AcquireResult::ASK_DRIVER;
+    }
+    case hmi_apis::Common_RCAccessMode::AUTO_ALLOW: {
+      LOG4CXX_DEBUG(logger_,
+                    "Current access_mode is AUTO_ALLOW. "
+                        << "App: " << app_id << " is allowed to acquire "
+                        << module_type);
+
+      SetResourceAquired(module_type, app_id);
+      return AcquireResult::ALLOWED;
+    }
+    default: { DCHECK_OR_RETURN(false, AcquireResult::IN_USE); }
+  }
+}
+
+void ResourceAllocationManagerImpl::ReleaseResource(
+    const std::string& module_type, const uint32_t application_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  LOG4CXX_DEBUG(logger_, "Release " << module_type << " by " << application_id);
+  SetResourceFree(module_type, application_id);
+}
+
+void ResourceAllocationManagerImpl::ProcessApplicationPolicyUpdate() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  Apps app_list = RCRPCPlugin::GetRCApplications(app_mngr_);
+
+  Apps::const_iterator app = app_list.begin();
+  for (; app_list.end() != app; ++app) {
+    application_manager::ApplicationSharedPtr app_ptr = *app;
+    const uint32_t application_id = app_ptr->app_id();
+    Resources acquired_modules = GetAcquiredResources(application_id);
+    std::sort(acquired_modules.begin(), acquired_modules.end());
+
+    Resources allowed_modules;
+    app_mngr_.GetPolicyHandler().GetModuleTypes((*app)->policy_app_id(),
+                                                &allowed_modules);
+    std::sort(allowed_modules.begin(), allowed_modules.end());
+
+    LOG4CXX_DEBUG(logger_,
+                  "Acquired modules: " << acquired_modules.size()
+                                       << " , allowed modules: "
+                                       << allowed_modules.size());
+
+    Resources disallowed_modules;
+    std::set_difference(acquired_modules.begin(),
+                        acquired_modules.end(),
+                        allowed_modules.begin(),
+                        allowed_modules.end(),
+                        std::back_inserter(disallowed_modules));
+
+    RCAppExtensionPtr rc_extention = GetApplicationExtention(app_ptr);
+    Resources::const_iterator module = disallowed_modules.begin();
+    for (; disallowed_modules.end() != module; ++module) {
+      ReleaseResource(*module, application_id);
+      if (rc_extention) {
+        rc_extention->UnsubscribeFromInteriorVehicleData(*module);
+      }
+    }
+  }
+}
+
+RCAppExtensionPtr ResourceAllocationManagerImpl::GetApplicationExtention(
+    application_manager::ApplicationSharedPtr application) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  RCAppExtensionPtr rc_app_extension;
+  if (!application) {
+    return rc_app_extension;
+  }
+
+  application_manager::AppExtensionPtr app_extension =
+      application->QueryInterface(RCRPCPlugin::kRCPluginID);
+  if (!app_extension) {
+    return rc_app_extension;
+  }
+
+  rc_app_extension =
+      application_manager::AppExtensionPtr::static_pointer_cast<RCAppExtension>(
+          app_extension);
+
+  return rc_app_extension;
+}
+
+void ResourceAllocationManagerImpl::RemoveAppsSubscriptions(const Apps& apps) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  Apps::const_iterator app = apps.begin();
+  for (; apps.end() != app; ++app) {
+    application_manager::ApplicationSharedPtr app_ptr = *app;
+    if (!app_ptr) {
+      continue;
+    }
+    RCAppExtensionPtr rc_extention = GetApplicationExtention(app_ptr);
+    if (rc_extention) {
+      rc_extention->UnsubscribeFromInteriorVehicleData();
+    }
+  }
+}
+
+void ResourceAllocationManagerImpl::SetResourceAquired(
+    const std::string& module_type, const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  allocated_resources_[module_type] = app_id;
+}
+
+void ResourceAllocationManagerImpl::SetResourceFree(
+    const std::string& module_type, const uint32_t app_id) {
+  AllocatedResources::const_iterator allocation =
+      allocated_resources_.find(module_type);
+  if (allocated_resources_.end() == allocation) {
+    LOG4CXX_DEBUG(logger_, "Resource " << module_type << " is not allocated.");
+    return;
+  }
+  if (app_id != allocation->second) {
+    LOG4CXX_ERROR(logger_,
+                  "Resource " << module_type
+                              << " is allocated by different application "
+                              << allocation->second);
+  }
+  allocated_resources_.erase(allocation);
+  LOG4CXX_DEBUG(logger_, "Resource " << module_type << " is released.");
+}
+
+std::vector<std::string> ResourceAllocationManagerImpl::GetAcquiredResources(
+    const uint32_t application_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  Resources allocated_resources;
+  AllocatedResources::const_iterator allocation = allocated_resources_.begin();
+  for (; allocated_resources_.end() != allocation; ++allocation) {
+    if (application_id == allocation->second) {
+      allocated_resources.push_back(allocation->first);
+    }
+  }
+
+  LOG4CXX_DEBUG(logger_,
+                "Application " << application_id << " acquired "
+                               << allocated_resources.size()
+                               << " resource(s).");
+
+  return allocated_resources;
+}
+
+void ResourceAllocationManagerImpl::SetResourceState(
+    const std::string& module_type,
+    const uint32_t app_id,
+    const ResourceState::eType state) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  LOG4CXX_DEBUG(logger_,
+                "Setting state for " << module_type << " by app_id " << app_id
+                                     << " to state " << state);
+  {
+    sync_primitives::AutoLock lock(allocated_resources_lock_);
+    const AllocatedResources::const_iterator allocated_it =
+        allocated_resources_.find(module_type);
+
+    const bool acquired = allocated_resources_.end() != allocated_it;
+    if (acquired) {
+      LOG4CXX_DEBUG(logger_,
+                    "Resource " << module_type << " is already acquired."
+                                << " Owner application id is "
+                                << allocated_it->second
+                                << " Changing application id is " << app_id);
+    } else {
+      LOG4CXX_DEBUG(logger_,
+                    "Resource " << module_type << " is not acquired yet");
+    }
+  }
+
+  sync_primitives::AutoLock lock(resources_state_lock_);
+  resources_state_[module_type] = state;
+  LOG4CXX_DEBUG(logger_, "Resource " << module_type << " got state " << state);
+}
+
+bool ResourceAllocationManagerImpl::IsResourceFree(
+    const std::string& module_type) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(resources_state_lock_);
+  const ResourcesState::const_iterator resource =
+      resources_state_.find(module_type);
+
+  if (resources_state_.end() == resource) {
+    LOG4CXX_DEBUG(logger_, "Resource " << module_type << " is free.");
+    return true;
+  }
+
+  LOG4CXX_DEBUG(logger_,
+                "Resource " << module_type << " state is " << resource->second);
+
+  return ResourceState::FREE == resource->second;
+}
+
+void ResourceAllocationManagerImpl::SetAccessMode(
+    const hmi_apis::Common_RCAccessMode::eType access_mode) {
+  if (hmi_apis::Common_RCAccessMode::ASK_DRIVER != access_mode) {
+    sync_primitives::AutoLock lock(rejected_resources_for_application_lock_);
+    rejected_resources_for_application_.clear();
+  }
+  current_access_mode_ = access_mode;
+}
+
+hmi_apis::Common_RCAccessMode::eType
+ResourceAllocationManagerImpl::GetAccessMode() const {
+  return current_access_mode_;
+}
+
+void ResourceAllocationManagerImpl::ForceAcquireResource(
+    const std::string& module_type, const uint32_t app_id) {
+  LOG4CXX_DEBUG(logger_, "Force " << app_id << " acquiring " << module_type);
+  sync_primitives::AutoLock lock(allocated_resources_lock_);
+  SetResourceAquired(module_type, app_id);
+}
+
+bool ResourceAllocationManagerImpl::IsModuleTypeRejected(
+    const std::string& module_type, const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(rejected_resources_for_application_lock_);
+  RejectedResources::iterator it =
+      rejected_resources_for_application_.find(app_id);
+
+  if (rejected_resources_for_application_.end() == it) {
+    return false;
+  }
+
+  const std::vector<std::string>& list_of_rejected_resources =
+      rejected_resources_for_application_[app_id];
+
+  return helpers::in_range(list_of_rejected_resources, module_type);
+}
+
+void ResourceAllocationManagerImpl::OnDriverDisallowed(
+    const std::string& module_type, const uint32_t app_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(rejected_resources_for_application_lock_);
+  auto it = rejected_resources_for_application_.find(app_id);
+
+  if (rejected_resources_for_application_.end() == it) {
+    rejected_resources_for_application_[app_id] = std::vector<std::string>();
+  }
+  std::vector<std::string>& list_of_rejected_resources =
+      rejected_resources_for_application_[app_id];
+  list_of_rejected_resources.push_back(module_type);
+}
+
+void ResourceAllocationManagerImpl::OnApplicationEvent(
+    application_manager::plugin_manager::ApplicationEvent event,
+    application_manager::ApplicationSharedPtr application) {
+  using application_manager::plugin_manager::ApplicationEvent;
+  LOG4CXX_AUTO_TRACE(logger_);
+  LOG4CXX_DEBUG(logger_,
+                "Event " << event << " came for " << application->app_id());
+
+  if (ApplicationEvent::kApplicationExit == event ||
+      ApplicationEvent::kApplicationUnregistered == event) {
+    Resources acquired_modules = GetAcquiredResources(application->app_id());
+    Resources::const_iterator module = acquired_modules.begin();
+    for (; acquired_modules.end() != module; ++module) {
+      ReleaseResource(*module, application->app_id());
+    }
+
+    Apps app_list;
+    app_list.push_back(application);
+    RemoveAppsSubscriptions(app_list);
+  }
+}
+
+void ResourceAllocationManagerImpl::OnPolicyEvent(
+    application_manager::plugin_manager::PolicyEvent event) {
+  using application_manager::plugin_manager::PolicyEvent;
+  LOG4CXX_AUTO_TRACE(logger_);
+  LOG4CXX_DEBUG(logger_, "Event " << event);
+
+  if (PolicyEvent::kApplicationPolicyUpdated == event) {
+    ProcessApplicationPolicyUpdate();
+    return;
+  }
+
+  if (PolicyEvent::kApplicationsDisabled == event) {
+    ResetAllAllocations();
+    Apps app_list = RCRPCPlugin::GetRCApplications(app_mngr_);
+    RemoveAppsSubscriptions(app_list);
+    return;
+  }
+}
+
+void ResourceAllocationManagerImpl::ResetAllAllocations() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  {
+    sync_primitives::AutoLock lock(resources_state_lock_);
+    resources_state_.clear();
+  }
+  {
+    sync_primitives::AutoLock lock(allocated_resources_lock_);
+    allocated_resources_.clear();
+  }
+  {
+    sync_primitives::AutoLock lock(rejected_resources_for_application_lock_);
+    rejected_resources_for_application_.clear();
+  }
+}
+
+}  // namespace rc_rpc_plugin
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/CMakeLists.txt b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/CMakeLists.txt
new file mode 100644
index 0000000000..a66ab107be
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/CMakeLists.txt
@@ -0,0 +1,75 @@
+# 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 copyright holders nor the names of their 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(${CMAKE_SOURCE_DIR}/tools/cmake/helpers/sources.cmake)
+
+include_directories (
+  ${GMOCK_INCLUDE_DIRECTORY}
+  ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${COMPONENTS_DIR}/application_manager/test/include
+  ${COMPONENTS_DIR}/application_manager/rpc_plugins/rc_rpc_plugin/test/include/
+  ${COMPONENTS_DIR}/include/test/application_manager/
+  ${COMPONENTS_DIR}/rc_rpc_plugin/test/include
+  )
+
+set (RC_TEST_SOURCES
+${CMAKE_CURRENT_SOURCE_DIR}/resource_allocation_manager_impl_test.cc
+)
+
+set(RC_COMMANDS_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/commands)
+
+file(GLOB SOURCES
+  ${COMPONENTS_DIR}/application_manager/test/mock_message_helper.cc
+  ${RC_COMMANDS_TEST_DIR}/*
+)
+
+set(LIBRARIES
+  RCRpcPluginStaticLib
+  ApplicationManager
+  SmartObjects
+  ProtocolHandler
+  MessageHelper
+  connectionHandler
+  Utils
+  jsoncpp
+  gmock_main
+  dl
+)
+
+if(ENABLE_LOG)
+  list(APPEND LIBRARIES log4cxx -L${LOG4CXX_LIBS_DIRECTORY})
+  list(APPEND LIBRARIES apr-1 -L${APR_LIBS_DIRECTORY})
+  list(APPEND LIBRARIES aprutil-1 -L${APR_UTIL_LIBS_DIRECTORY})
+  list(APPEND LIBRARIES expat -L${EXPAT_LIBS_DIRECTORY})
+endif()
+
+create_test("rc_commands_test" "${SOURCES}" "${LIBRARIES}" )
+create_test("resource_allocation_manager_test" "${RC_TEST_SOURCES}" "${LIBRARIES}")
+
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/CMakeLists.txt b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/CMakeLists.txt
new file mode 100644
index 0000000000..9ea47dca38
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/CMakeLists.txt
@@ -0,0 +1,62 @@
+# 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(${CMAKE_SOURCE_DIR}/tools/cmake/helpers/sources.cmake)
+
+include_directories(
+  ${GMOCK_INCLUDE_DIRECTORY}
+  ${COMPONENTS_DIR}/rc_rpc_plugin/include/
+  ${COMPONENTS_DIR}/rc_rpc_plugin/include/rc_rpc_plugin/
+  ${COMPONENTS_DIR}/rc_rpc_plugin/include/rc_rpc_plugin/commands/
+  ${COMPONENTS_DIR}/rc_rpc_plugin/test/include
+)
+
+set(RC_COMMANDS_TEST_DIR ${RC_TEST_DIR}/commands)
+
+file(GLOB SOURCES
+  ${COMPONENTS_DIR}/application_manager/test/mock_message_helper.cc
+  ${RC_COMMANDS_TEST_DIR}/*
+)
+
+set(LIBRARIES
+  gmock
+  RemoteControlModule
+  Utils
+  SmartObjects
+  jsoncpp
+  HMI_API
+  MOBILE_API
+  ApplicationManager
+  AMHMICommandsLibrary
+  AMMobileCommandsLibrary
+  connectionHandler
+)
+
+create_test("rc_commands_test" "${SOURCES}" "${LIBRARIES}" )
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/button_press_request_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/button_press_request_test.cc
new file mode 100644
index 0000000000..5098f6472e
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/button_press_request_test.cc
@@ -0,0 +1,319 @@
+/*
+ * 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/commands/mobile/button_press_request.h"
+#include "rc_rpc_plugin/rc_command_factory.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "rc_rpc_plugin/mock/mock_resource_allocation_manager.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "utils/shared_ptr.h"
+#include "utils/make_shared.h"
+#include "interfaces/HMI_API.h"
+#include "interfaces/MOBILE_API.h"
+
+using test::components::application_manager_test::MockApplication;
+using test::components::commands_test::CommandRequestTest;
+using test::components::commands_test::CommandsTestMocks;
+using test::components::commands_test::HMIResultCodeIs;
+using test::components::commands_test::MobileResultCodeIs;
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::SaveArg;
+using ::application_manager::Message;
+using ::application_manager::MessageType;
+using application_manager::commands::MessageSharedPtr;
+using ::protocol_handler::MessagePriority;
+
+namespace {
+const int kModuleId = 153u;
+const uint32_t kConnectionKey = 1u;
+const uint32_t kAppId = 0u;
+const std::string kPolicyAppId = "Test";
+}
+
+namespace rc_rpc_plugin_test {
+
+using namespace rc_rpc_plugin;
+
+class ButtonPressRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  ButtonPressRequestTest()
+      : rc_capabilities_(smart_objects::SmartType_Map)
+      , mock_app_(utils::MakeShared<NiceMock<MockApplication> >())
+      , rc_app_extention_(
+            utils::MakeShared<rc_rpc_plugin::RCAppExtension>(kModuleId)) {}
+
+  smart_objects::SmartObject ButtonCapability(
+      const mobile_apis::ButtonName::eType button_name) {
+    smart_objects::SmartObject button(smart_objects::SmartType_Map);
+    button["name"] = button_name;
+    return button;
+  }
+
+  void SetUp() OVERRIDE {
+    using namespace mobile_apis;
+
+    std::vector<ButtonName::eType> button_names = {ButtonName::AC_MAX,
+                                                   ButtonName::AC,
+                                                   ButtonName::RECIRCULATE,
+                                                   ButtonName::FAN_UP,
+                                                   ButtonName::FAN_DOWN,
+                                                   ButtonName::TEMP_UP,
+                                                   ButtonName::TEMP_DOWN,
+                                                   ButtonName::DEFROST_MAX,
+                                                   ButtonName::DEFROST,
+                                                   ButtonName::DEFROST_REAR,
+                                                   ButtonName::UPPER_VENT,
+                                                   ButtonName::LOWER_VENT,
+                                                   ButtonName::VOLUME_UP,
+                                                   ButtonName::VOLUME_DOWN,
+                                                   ButtonName::EJECT,
+                                                   ButtonName::SOURCE,
+                                                   ButtonName::SHUFFLE,
+                                                   ButtonName::REPEAT};
+
+    smart_objects::SmartObject button_caps(smart_objects::SmartType_Array);
+    for (size_t i = 0; i < button_names.size(); i++) {
+      button_caps[i] = ButtonCapability(button_names[i]);
+    }
+    rc_capabilities_[strings::kbuttonCapabilities] = button_caps;
+    ON_CALL(app_mngr_, application(_)).WillByDefault(Return(mock_app_));
+    ON_CALL(mock_allocation_manager_, GetApplicationExtention(_))
+        .WillByDefault(Return(rc_app_extention_));
+    ON_CALL(app_mngr_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_));
+    ON_CALL(app_mngr_, hmi_capabilities())
+        .WillByDefault(ReturnRef(mock_hmi_capabilities_));
+    ON_CALL(mock_hmi_capabilities_, rc_capability())
+        .WillByDefault(Return(&rc_capabilities_));
+    ON_CALL(*mock_app_, policy_app_id()).WillByDefault(Return(kPolicyAppId));
+    ON_CALL(mock_policy_handler_,
+            CheckHMIType(kPolicyAppId,
+                         mobile_apis::AppHMIType::eType::REMOTE_CONTROL,
+                         nullptr)).WillByDefault(Return(true));
+  }
+
+  MessageSharedPtr CreateBasicMessage() {
+    MessageSharedPtr message = CreateMessage();
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  mobile_apis::FunctionID::ButtonPressID;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kConnectionKey;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kAppId;
+    return message;
+  }
+
+  template <class Command>
+  application_manager::SharedPtr<Command> CreateRCCommand(
+      MessageSharedPtr& msg) {
+    InitCommand(kDefaultTimeout_);
+    return ::utils::MakeShared<Command>(msg ? msg : msg = CreateMessage(),
+                                        app_mngr_,
+                                        mock_rpc_service_,
+                                        mock_hmi_capabilities_,
+                                        mock_policy_handler_,
+                                        mock_allocation_manager_);
+  }
+
+ protected:
+  smart_objects::SmartObject rc_capabilities_;
+  utils::SharedPtr<MockApplication> mock_app_;
+  utils::SharedPtr<rc_rpc_plugin::RCAppExtension> rc_app_extention_;
+  test::components::policy_test::MockPolicyHandlerInterface
+      mock_policy_handler_;
+  testing::NiceMock<rc_rpc_plugin_test::MockResourceAllocationManager>
+      mock_allocation_manager_;
+};
+
+TEST_F(ButtonPressRequestTest,
+       Execute_ButtonNameMatchesModuleType_ExpectCorrectMessageSentToHMI) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::CLIMATE;
+  msg_params[message_params::kButtonName] = mobile_apis::ButtonName::AC;
+  msg_params[message_params::kButtonPressMode] =
+      mobile_apis::ButtonPressMode::SHORT;
+
+  // Expectations
+  const std::string resource = "CLIMATE";
+  ON_CALL(mock_policy_handler_, CheckModule(_, _)).WillByDefault(Return(true));
+  EXPECT_CALL(mock_allocation_manager_, IsResourceFree(resource))
+      .WillOnce(Return(true));
+  EXPECT_CALL(mock_allocation_manager_, AcquireResource(resource, _))
+      .WillOnce(Return(rc_rpc_plugin::AcquireResult::ALLOWED));
+  EXPECT_CALL(
+      mock_allocation_manager_,
+      SetResourceState(resource, kAppId, rc_rpc_plugin::ResourceState::BUSY));
+  EXPECT_CALL(mock_rpc_service_,
+              ManageHMICommand(
+                  HMIResultCodeIs(hmi_apis::FunctionID::Buttons_ButtonPress)))
+      .WillOnce(Return(true));
+
+  // Act
+  application_manager::SharedPtr<rc_rpc_plugin::commands::ButtonPressRequest>
+      command = CreateRCCommand<rc_rpc_plugin::commands::ButtonPressRequest>(
+          mobile_message);
+  ASSERT_TRUE(command->Init());
+  command->Run();
+}
+
+TEST_F(
+    ButtonPressRequestTest,
+    Execute_ButtonNameDoesNotMatchModuleType_ExpectMessageNotSentToHMI_AndFalseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::RADIO;
+  msg_params[message_params::kButtonName] = mobile_apis::ButtonName::AC;
+  msg_params[message_params::kButtonPressMode] =
+      mobile_apis::ButtonPressMode::SHORT;
+  // Expectations
+
+  const std::string resource = "RADIO";
+  ON_CALL(mock_policy_handler_, CheckModule(_, _)).WillByDefault(Return(true));
+  EXPECT_CALL(mock_allocation_manager_, IsResourceFree(resource))
+      .WillOnce(Return(true));
+  EXPECT_CALL(mock_allocation_manager_, AcquireResource(resource, _))
+      .WillOnce(Return(rc_rpc_plugin::AcquireResult::ALLOWED));
+  EXPECT_CALL(mock_allocation_manager_, SetResourceState(resource, kAppId, _))
+      .Times(2);
+
+  EXPECT_CALL(mock_rpc_service_,
+              ManageHMICommand(HMIResultCodeIs(
+                  hmi_apis::FunctionID::Buttons_ButtonPress))).Times(0);
+  MessageSharedPtr command_result;
+  EXPECT_CALL(mock_rpc_service_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _))
+      .WillOnce(DoAll(SaveArg<0>(&command_result), Return(true)));
+
+  // Act
+  application_manager::SharedPtr<rc_rpc_plugin::commands::ButtonPressRequest>
+      command = CreateRCCommand<rc_rpc_plugin::commands::ButtonPressRequest>(
+          mobile_message);
+  ASSERT_TRUE(command->Init());
+  command->Run();
+}
+
+TEST_F(ButtonPressRequestTest, OnEvent_ExpectSuccessfullResponseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::CLIMATE;
+  msg_params[message_params::kButtonName] = mobile_apis::ButtonName::AC;
+  msg_params[message_params::kButtonPressMode] =
+      mobile_apis::ButtonPressMode::SHORT;
+
+  MessageSharedPtr hmi_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& hmi_msg_params =
+      (*hmi_message)[application_manager::strings::msg_params];
+  hmi_apis::Common_Result::eType response_code =
+      hmi_apis::Common_Result::SUCCESS;
+  hmi_msg_params[application_manager::hmi_response::code] = response_code;
+  hmi_msg_params[application_manager::strings::connection_key] = kConnectionKey;
+
+  // Expectations
+  EXPECT_CALL(mock_allocation_manager_,
+              SetResourceState(_, kAppId, rc_rpc_plugin::ResourceState::FREE))
+      .Times(2);
+
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS), _))
+      .WillOnce(Return(true));
+
+  // Act
+  application_manager::event_engine::Event event(
+      hmi_apis::FunctionID::Buttons_ButtonPress);
+  event.set_smart_object(*hmi_message);
+  application_manager::SharedPtr<rc_rpc_plugin::commands::ButtonPressRequest>
+      command = CreateRCCommand<rc_rpc_plugin::commands::ButtonPressRequest>(
+          mobile_message);
+  command->on_event(event);
+}
+
+TEST_F(ButtonPressRequestTest,
+       OnEvent_ReadOnlyParamFromHMI_ExpectFalseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::CLIMATE;
+  msg_params[message_params::kButtonName] = mobile_apis::ButtonName::AC;
+  msg_params[message_params::kButtonPressMode] =
+      mobile_apis::ButtonPressMode::SHORT;
+
+  MessageSharedPtr hmi_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& hmi_msg_params =
+      (*hmi_message)[application_manager::strings::params];
+  hmi_apis::Common_Result::eType response_code =
+      hmi_apis::Common_Result::READ_ONLY;
+  hmi_msg_params[application_manager::hmi_response::code] = response_code;
+  hmi_msg_params[application_manager::strings::connection_key] = kConnectionKey;
+
+  // Expectations
+  EXPECT_CALL(mock_allocation_manager_,
+              SetResourceState(_, kAppId, rc_rpc_plugin::ResourceState::FREE))
+      .Times(2);
+
+  EXPECT_CALL(mock_rpc_service_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _))
+      .WillOnce(Return(false));
+
+  // Act
+  application_manager::event_engine::Event event(
+      hmi_apis::FunctionID::Buttons_ButtonPress);
+  event.set_smart_object(*hmi_message);
+  application_manager::SharedPtr<rc_rpc_plugin::commands::ButtonPressRequest>
+      command = CreateRCCommand<rc_rpc_plugin::commands::ButtonPressRequest>(
+          mobile_message);
+  command->on_event(event);
+}
+
+}  // namespace rc_rpc_plugin_test
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/get_interior_vehicle_data_request_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/get_interior_vehicle_data_request_test.cc
new file mode 100644
index 0000000000..7074bfb9c5
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/get_interior_vehicle_data_request_test.cc
@@ -0,0 +1,238 @@
+/*
+ * 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 "rc_rpc_plugin/commands/mobile/get_interior_vehicle_data_request.h"
+#include "gtest/gtest.h"
+#include "application_manager/mock_application.h"
+#include "rc_rpc_plugin/rc_app_extension.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "application_manager/message_helper.h"
+#include "rc_rpc_plugin/rc_command_factory.h"
+#include "application_manager/event_engine/event_dispatcher.h"
+#include "application_manager/commands/command_request_test.h"
+#include "rc_rpc_plugin/mock/mock_resource_allocation_manager.h"
+#include "utils/shared_ptr.h"
+#include "utils/make_shared.h"
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::StrictMock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::SaveArg;
+using ::application_manager::Message;
+using ::application_manager::MessageType;
+using application_manager::commands::MessageSharedPtr;
+using ::application_manager::ApplicationSharedPtr;
+using ::protocol_handler::MessagePriority;
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockApplicationManager;
+using test::components::commands_test::MockApplicationManager;
+using test::components::commands_test::CommandRequestTest;
+using test::components::commands_test::CommandsTestMocks;
+using test::components::commands_test::HMIResultCodeIs;
+using test::components::commands_test::MobileResultCodeIs;
+
+namespace {
+const int32_t kConnectionKey = 5u;
+const uint32_t kAppId = 0u;
+const int kModuleId = 153u;
+}
+
+namespace rc_rpc_plugin_test {
+
+using namespace rc_rpc_plugin;
+class GetInteriorVehicleDataRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  GetInteriorVehicleDataRequestTest()
+      : mock_app_(utils::MakeShared<NiceMock<MockApplication> >())
+      , rc_app_extention_(utils::MakeShared<RCAppExtension>(kModuleId)) {
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(mock_hmi_interfaces_));
+
+    ON_CALL(
+        mock_hmi_interfaces_,
+        GetInterfaceState(application_manager::HmiInterfaces::HMI_INTERFACE_RC))
+        .WillByDefault(Return(application_manager::HmiInterfaces::
+                                  InterfaceState::STATE_AVAILABLE));
+    ON_CALL(app_mngr_, application(kAppId)).WillByDefault(Return(mock_app_));
+    ON_CALL(mock_allocation_manager_, GetApplicationExtention(_))
+        .WillByDefault(Return(rc_app_extention_));
+    ON_CALL(app_mngr_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_));
+    ON_CALL(app_mngr_, hmi_capabilities())
+        .WillByDefault(ReturnRef(mock_hmi_capabilities_));
+    ON_CALL(mock_hmi_capabilities_, rc_capability())
+        .WillByDefault(Return(&rc_capabilities_));
+    ON_CALL(mock_policy_handler_,
+            CheckHMIType(
+                _, mobile_apis::AppHMIType::eType::REMOTE_CONTROL, nullptr))
+        .WillByDefault(Return(true));
+  }
+
+  MessageSharedPtr CreateBasicMessage() {
+    MessageSharedPtr message = CreateMessage();
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  mobile_apis::FunctionID::GetInteriorVehicleDataID;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kConnectionKey;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kAppId;
+    return message;
+  }
+  template <class Command>
+  application_manager::SharedPtr<Command> CreateRCCommand(
+      MessageSharedPtr& msg) {
+    InitCommand(kDefaultTimeout_);
+    return ::utils::MakeShared<Command>(msg ? msg : msg = CreateMessage(),
+                                        app_mngr_,
+                                        mock_rpc_service_,
+                                        mock_hmi_capabilities_,
+                                        mock_policy_handler_,
+                                        mock_allocation_manager_);
+  }
+
+ protected:
+  smart_objects::SmartObject rc_capabilities_;
+  utils::SharedPtr<MockApplication> mock_app_;
+  utils::SharedPtr<RCAppExtension> rc_app_extention_;
+  testing::NiceMock<rc_rpc_plugin_test::MockResourceAllocationManager>
+      mock_allocation_manager_;
+};
+TEST_F(GetInteriorVehicleDataRequestTest,
+       Execute_MessageValidationOk_ExpectCorrectMessageSentToHMI) {
+  // Arrange
+  ON_CALL(mock_policy_handler_, CheckModule(_, _)).WillByDefault(Return(true));
+  EXPECT_CALL(mock_hmi_capabilities_, rc_capability())
+      .WillOnce(Return(nullptr));
+  EXPECT_CALL(mock_rpc_service_,
+              ManageHMICommand(HMIResultCodeIs(
+                  hmi_apis::FunctionID::RC_GetInteriorVehicleData)))
+      .WillOnce(Return(true));
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::GetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::GetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->Run();
+}
+
+TEST_F(
+    GetInteriorVehicleDataRequestTest,
+    Execute_MessageValidationFailed_ExpectMessageNotSentToHMI_AndFalseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::RADIO;
+  ON_CALL(mock_policy_handler_, CheckModule(_, _)).WillByDefault(Return(true));
+  MessageSharedPtr command_result;
+  EXPECT_CALL(mock_rpc_service_,
+              ManageHMICommand(HMIResultCodeIs(
+                  hmi_apis::FunctionID::RC_GetInteriorVehicleData))).Times(0);
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(
+          MobileResultCodeIs(mobile_apis::Result::UNSUPPORTED_RESOURCE), _))
+      .WillOnce(DoAll(SaveArg<0>(&command_result), Return(true)));
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::GetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::GetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->Run();
+}
+
+TEST_F(GetInteriorVehicleDataRequestTest,
+       OnEvent_ValidHmiResponse_ExpectSuccessfullResponseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::CLIMATE;
+
+  MessageSharedPtr hmi_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& hmi_msg_params =
+      (*hmi_message)[application_manager::strings::msg_params];
+  hmi_apis::Common_Result::eType response_code =
+      hmi_apis::Common_Result::SUCCESS;
+  hmi_msg_params[application_manager::hmi_response::code] = response_code;
+  hmi_msg_params[application_manager::strings::connection_key] = kConnectionKey;
+
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(MobileResultCodeIs(mobile_apis::Result::SUCCESS), _))
+      .WillOnce(Return(true));
+
+  application_manager::event_engine::Event event(
+      hmi_apis::FunctionID::RC_GetInteriorVehicleData);
+  event.set_smart_object(*hmi_message);
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::GetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::GetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->on_event(event);
+}
+
+TEST_F(GetInteriorVehicleDataRequestTest,
+       OnEvent_InvalidHmiResponse_ExpectGenericErrorResponseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleType] = mobile_apis::ModuleType::CLIMATE;
+
+  MessageSharedPtr hmi_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& hmi_msg_params =
+      (*hmi_message)[application_manager::strings::params];
+  hmi_apis::Common_Result::eType response_code =
+      hmi_apis::Common_Result::READ_ONLY;
+  hmi_msg_params[application_manager::hmi_response::code] = response_code;
+  hmi_msg_params[application_manager::strings::connection_key] = kConnectionKey;
+  EXPECT_CALL(mock_rpc_service_,
+              ManageMobileCommand(
+                  MobileResultCodeIs(mobile_apis::Result::GENERIC_ERROR), _))
+      .WillOnce(Return(false));
+
+  application_manager::event_engine::Event event(
+      hmi_apis::FunctionID::RC_GetInteriorVehicleData);
+  event.set_smart_object(*hmi_message);
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::GetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::GetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->on_event(event);
+}
+}  // namespace rc_rpc_plugin_test
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/on_interior_vehicle_data_notification_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/on_interior_vehicle_data_notification_test.cc
new file mode 100644
index 0000000000..78d20c6b13
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/on_interior_vehicle_data_notification_test.cc
@@ -0,0 +1,140 @@
+/*
+ * 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 "application_manager/application.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/commands/commands_test.h"
+#include "rc_rpc_plugin/commands/mobile/on_interior_vehicle_data_notification.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "rc_rpc_plugin/mock/mock_resource_allocation_manager.h"
+#include "gtest/gtest.h"
+#include "interfaces/MOBILE_API.h"
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::NiceMock;
+using ::testing::SaveArg;
+using ::testing::Mock;
+using application_manager::ApplicationSet;
+using application_manager::commands::MessageSharedPtr;
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockApplicationManager;
+using test::components::commands_test::CommandsTest;
+using test::components::commands_test::CommandsTestMocks;
+
+namespace {
+const uint32_t kAppId = 0u;
+const uint32_t kConnectionKey = 1u;
+const std::string kPolicyAppId = "Test";
+}
+
+namespace rc_rpc_plugin_test {
+using namespace rc_rpc_plugin;
+using application_manager::ApplicationSet;
+
+class OnInteriorVehicleDataNotificationTest
+    : public CommandsTest<CommandsTestMocks::kIsNice> {
+ public:
+  OnInteriorVehicleDataNotificationTest()
+      : mock_app_(utils::MakeShared<NiceMock<MockApplication> >()) {}
+
+  MessageSharedPtr CreateBasicMessage() {
+    MessageSharedPtr message = CreateMessage();
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  mobile_apis::FunctionID::SetInteriorVehicleDataID;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kConnectionKey;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kAppId;
+    smart_objects::SmartObject& msg_param =
+        (*message)[application_manager::strings::msg_params];
+    msg_param[message_params::kModuleType] = mobile_apis::ModuleType::CLIMATE;
+
+    return message;
+  }
+
+  template <class Command>
+  application_manager::SharedPtr<Command> CreateRCCommand(
+      MessageSharedPtr& msg) {
+    InitCommand(kDefaultTimeout_);
+    return ::utils::MakeShared<Command>(msg ? msg : msg = CreateMessage(),
+                                        app_mngr_,
+                                        mock_rpc_service_,
+                                        mock_hmi_capabilities_,
+                                        mock_policy_handler_,
+                                        mock_allocation_manager_);
+  }
+
+ protected:
+  utils::SharedPtr<MockApplication> mock_app_;
+  testing::NiceMock<rc_rpc_plugin_test::MockResourceAllocationManager>
+      mock_allocation_manager_;
+};
+
+TEST_F(OnInteriorVehicleDataNotificationTest,
+       Run_SendMessageToMobile_Notification) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  ApplicationSet app_set = {mock_app_};
+  MessageSharedPtr message;
+  std::shared_ptr<sync_primitives::Lock> apps_lock =
+      std::make_shared<sync_primitives::Lock>();
+  DataAccessor<ApplicationSet> accessor(app_set, apps_lock);
+  // Expectations
+  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+  rc_extention_ptr->SubscribeToInteriorVehicleData(enums_value::kClimate);
+  ON_CALL(*mock_app_, QueryInterface(_))
+      .WillByDefault(Return(rc_extention_ptr));
+  ON_CALL(*mock_app_, is_remote_control_supported())
+      .WillByDefault(Return(true));
+
+  EXPECT_CALL(mock_rpc_service_, SendMessageToMobile(_, false))
+      .WillOnce(SaveArg<0>(&message));
+  // Act
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::OnInteriorVehicleDataNotification> command =
+      CreateRCCommand<
+          rc_rpc_plugin::commands::OnInteriorVehicleDataNotification>(
+          mobile_message);
+  command->Run();
+  // Assertions
+  ASSERT_TRUE(message);
+  Mock::VerifyAndClearExpectations(&app_mngr_);
+}
+
+}  // namespace rc_rpc_plugin_test
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/on_remote_control_settings_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/on_remote_control_settings_test.cc
new file mode 100644
index 0000000000..f3ac768a4e
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/on_remote_control_settings_test.cc
@@ -0,0 +1,163 @@
+/*
+ * 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 "application_manager/application.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/commands/commands_test.h"
+#include "rc_rpc_plugin/commands/hmi/rc_on_remote_control_settings_notification.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "rc_rpc_plugin/mock/mock_resource_allocation_manager.h"
+#include "gtest/gtest.h"
+#include "interfaces/MOBILE_API.h"
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::NiceMock;
+using ::testing::SaveArg;
+using ::testing::Mock;
+using application_manager::ApplicationSet;
+using application_manager::commands::MessageSharedPtr;
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockApplicationManager;
+using test::components::commands_test::CommandsTest;
+using test::components::commands_test::CommandsTestMocks;
+
+namespace {
+const uint32_t kAppId = 0u;
+const uint32_t kConnectionKey = 1u;
+const std::string kPolicyAppId = "Test";
+}
+
+namespace rc_rpc_plugin_test {
+using namespace rc_rpc_plugin;
+using application_manager::ApplicationSet;
+
+class RCOnRemoteControlSettingsNotificationTest
+    : public CommandsTest<CommandsTestMocks::kIsNice> {
+ public:
+  RCOnRemoteControlSettingsNotificationTest()
+      : mock_app_(utils::MakeShared<NiceMock<MockApplication> >()) {}
+  MessageSharedPtr CreateBasicMessage() {
+    MessageSharedPtr message = CreateMessage();
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  mobile_apis::FunctionID::SetInteriorVehicleDataID;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kConnectionKey;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kAppId;
+    smart_objects::SmartObject& msg_param =
+        (*message)[application_manager::strings::msg_params];
+    msg_param[message_params::kModuleType] = enums_value::kClimate;
+
+    return message;
+  }
+
+  template <class Command>
+  application_manager::SharedPtr<Command> CreateRCCommand(
+      MessageSharedPtr& msg) {
+    InitCommand(kDefaultTimeout_);
+    return ::utils::MakeShared<Command>(msg ? msg : msg = CreateMessage(),
+                                        app_mngr_,
+                                        mock_rpc_service_,
+                                        mock_hmi_capabilities_,
+                                        mock_policy_handler_,
+                                        mock_allocation_manager_);
+  }
+
+ protected:
+  utils::SharedPtr<MockApplication> mock_app_;
+  testing::NiceMock<rc_rpc_plugin_test::MockResourceAllocationManager>
+      mock_allocation_manager_;
+};
+
+TEST_F(RCOnRemoteControlSettingsNotificationTest,
+       Run_Allowed_SetAccessMode) {  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  (*mobile_message)[application_manager::strings::msg_params]
+                   [message_params::kAllowed] = true;
+
+  // Expectations
+
+  ON_CALL(mock_allocation_manager_, GetAccessMode())
+      .WillByDefault(Return(hmi_apis::Common_RCAccessMode::ASK_DRIVER));
+
+  EXPECT_CALL(mock_allocation_manager_,
+              SetAccessMode(hmi_apis::Common_RCAccessMode::ASK_DRIVER));
+  // Act
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::RCOnRemoteControlSettingsNotification> command =
+      CreateRCCommand<
+          rc_rpc_plugin::commands::RCOnRemoteControlSettingsNotification>(
+          mobile_message);
+
+  command->Run();
+}
+
+TEST_F(RCOnRemoteControlSettingsNotificationTest,
+       Run_NotAllowed_ResetAllAllocations) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  (*mobile_message)[application_manager::strings::msg_params]
+                   [message_params::kAllowed] = false;
+
+  ApplicationSet app_set = {mock_app_};
+
+  std::shared_ptr<sync_primitives::Lock> apps_lock =
+      std::make_shared<sync_primitives::Lock>();
+  DataAccessor<ApplicationSet> accessor(app_set, apps_lock);
+  // Expectations
+  EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+  rc_extention_ptr->SubscribeToInteriorVehicleData(enums_value::kClimate);
+  ON_CALL(*mock_app_, QueryInterface(_))
+      .WillByDefault(Return(rc_extention_ptr));
+
+  EXPECT_CALL(mock_allocation_manager_, ResetAllAllocations());
+
+  // Act
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::RCOnRemoteControlSettingsNotification> command =
+      CreateRCCommand<
+          rc_rpc_plugin::commands::RCOnRemoteControlSettingsNotification>(
+          mobile_message);
+
+  command->Run();
+  Mock::VerifyAndClearExpectations(&app_mngr_);
+}
+
+}  // namespace rc_rpc_plugin_test
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/rc_get_interior_vehicle_data_consent_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/rc_get_interior_vehicle_data_consent_test.cc
new file mode 100644
index 0000000000..8fad1aef60
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/rc_get_interior_vehicle_data_consent_test.cc
@@ -0,0 +1,239 @@
+/*
+ * 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 "application_manager/application.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/rpc_service_impl.h"
+#include "application_manager/mock_request_controller_settings.h"
+#include "application_manager/include/application_manager/command_holder_impl.h"
+#include "application_manager/mock_hmi_capabilities.h"
+#include "application_manager/request_controller.h"
+#include "application_manager/mock_rpc_plugin_manager.h"
+#include "application_manager/mock_rpc_plugin.h"
+#include "application_manager/mock_command_factory.h"
+#include "application_manager/mock_event_dispatcher.h"
+#include "application_manager/message.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "rc_rpc_plugin/mock/mock_resource_allocation_manager.h"
+#include "rc_rpc_plugin/commands/mobile/button_press_request.h"
+#include "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_response.h"
+#include "rc_rpc_plugin/commands/hmi/rc_get_interior_vehicle_data_consent_request.h"
+#include "hmi_message_handler/mock_hmi_message_handler.h"
+#include "interfaces/MOBILE_API.h"
+#include "include/test/protocol_handler/mock_protocol_handler.h"
+#include "test/application_manager/mock_application_manager_settings.h"
+#include "utils/make_shared.h"
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::NiceMock;
+using ::testing::SaveArg;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::utils::SharedPtr;
+namespace am = ::application_manager;
+using am::ApplicationSet;
+using am::commands::MessageSharedPtr;
+using am::commands::CommandImpl;
+using am::plugin_manager::RPCPlugin;
+using ::smart_objects::SmartObject;
+using rc_rpc_plugin::commands::ButtonPressRequest;
+using rc_rpc_plugin::commands::RCGetInteriorVehicleDataConsentResponse;
+using rc_rpc_plugin::commands::RCGetInteriorVehicleDataConsentRequest;
+using rc_rpc_plugin::RCRPCPlugin;
+using test::components::commands_test::CommandsTestMocks;
+using test::components::commands_test::CommandRequestTest;
+using am::plugin_manager::MockRPCPluginManager;
+using am::plugin_manager::MockRPCPlugin;
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockRequestControlerSettings;
+using test::components::protocol_handler_test::MockProtocolHandler;
+using test::components::hmi_message_handler_test::MockHMIMessageHandler;
+using test::components::application_manager_test::MockHMICapabilities;
+using test::components::application_manager_test::MockCommandFactory;
+using test::components::policy_test::MockPolicyHandlerInterface;
+
+namespace rc_rpc_plugin_test {
+using namespace rc_rpc_plugin;
+
+namespace {
+const uint32_t kConnectionKey = 2u;
+const uint32_t kAppId = 5u;
+const std::string kResource = "CLIMATE";
+const uint32_t kPluginID = RCRPCPlugin::kRCPluginID;
+}  // namespace
+
+class RCGetInteriorVehicleDataConsentTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  RCGetInteriorVehicleDataConsentTest()
+      : mock_app_(utils::MakeShared<NiceMock<MockApplication> >())
+      , command_holder(app_mngr_)
+      , request_controller(mock_request_controler)
+      , rpc_service(app_mngr_,
+                    request_controller,
+                    &mock_protocol_handler,
+                    &mock_hmi_handler,
+                    command_holder)
+      , rc_app_extention_(utils::MakeShared<RCAppExtension>(kPluginID))
+      , mock_rpc_plugin_manager(
+            utils::MakeShared<NiceMock<MockRPCPluginManager> >())
+      , rpc_plugin(mock_rpc_plugin)
+      , optional_mock_rpc_plugin(mock_rpc_plugin) {
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(mock_hmi_interfaces_));
+    ON_CALL(
+        mock_hmi_interfaces_,
+        GetInterfaceState(application_manager::HmiInterfaces::HMI_INTERFACE_RC))
+        .WillByDefault(Return(application_manager::HmiInterfaces::
+                                  InterfaceState::STATE_AVAILABLE));
+    ON_CALL(app_mngr_, application(kAppId)).WillByDefault(Return(mock_app_));
+    ON_CALL(mock_allocation_manager_, GetApplicationExtention(_))
+        .WillByDefault(Return(rc_app_extention_));
+    ON_CALL(app_mngr_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_));
+    ON_CALL(app_mngr_, hmi_capabilities())
+        .WillByDefault(ReturnRef(mock_hmi_capabilities_));
+    ON_CALL(mock_hmi_capabilities_, rc_capability())
+        .WillByDefault(Return(&rc_capabilities_));
+    ON_CALL(mock_policy_handler_,
+            CheckHMIType(
+                _, mobile_apis::AppHMIType::eType::REMOTE_CONTROL, nullptr))
+        .WillByDefault(Return(true));
+    ON_CALL(mock_policy_handler_, CheckModule(_, _))
+        .WillByDefault(Return(true));
+    ON_CALL(app_mngr_, GetPluginManager())
+        .WillByDefault(ReturnRef(*mock_rpc_plugin_manager));
+    ON_CALL(*mock_rpc_plugin_manager, FindPluginToProcess(_, _))
+        .WillByDefault(Return(rpc_plugin));
+    ON_CALL(mock_allocation_manager_, IsResourceFree(kResource))
+        .WillByDefault(Return(true));
+  }
+
+  template <class Command>
+  application_manager::SharedPtr<Command> CreateRCCommand(
+      MessageSharedPtr& msg) {
+    InitCommand(kDefaultTimeout_);
+    return ::utils::MakeShared<Command>(msg ? msg : msg = CreateMessage(),
+                                        app_mngr_,
+                                        rpc_service,
+                                        mock_hmi_capabilities_,
+                                        mock_policy_handler_,
+                                        mock_allocation_manager_);
+  }
+
+  MessageSharedPtr CreateBasicMessage() {
+    MessageSharedPtr message = CreateMessage();
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  mobile_apis::FunctionID::ButtonPressID;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kConnectionKey;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kAppId;
+    return message;
+  }
+
+ protected:
+  utils::SharedPtr<MockApplication> mock_app_;
+  MockRequestControlerSettings mock_request_controler;
+  MockProtocolHandler mock_protocol_handler;
+  MockHMIMessageHandler mock_hmi_handler;
+  am::CommandHolderImpl command_holder;
+  testing::NiceMock<rc_rpc_plugin_test::MockResourceAllocationManager>
+      mock_allocation_manager_;
+  smart_objects::SmartObject rc_capabilities_;
+  MockRPCPlugin mock_rpc_plugin;
+  MockCommandFactory mock_command_factory;
+  am::request_controller::RequestController request_controller;
+  am::rpc_service::RPCServiceImpl rpc_service;
+  utils::SharedPtr<RCAppExtension> rc_app_extention_;
+  utils::SharedPtr<am::plugin_manager::MockRPCPluginManager>
+      mock_rpc_plugin_manager;
+  utils::Optional<RPCPlugin> rpc_plugin;
+  utils::Optional<MockRPCPlugin> optional_mock_rpc_plugin;
+};
+
+TEST_F(RCGetInteriorVehicleDataConsentTest,
+       Run_MobileSendButtonPressMessage_HMISendASKDRIVERModeToMobile) {
+  // Arrange
+  auto mobile_message = CreateBasicMessage();
+
+  // Expectations
+  EXPECT_CALL(mock_allocation_manager_, AcquireResource(_, _))
+      .WillOnce(Return(rc_rpc_plugin::AcquireResult::ASK_DRIVER));
+  EXPECT_CALL(*optional_mock_rpc_plugin, GetCommandFactory())
+      .WillOnce(ReturnRef(mock_command_factory));
+  auto rc_consent_request =
+      CreateRCCommand<commands::RCGetInteriorVehicleDataConsentRequest>(
+          mobile_message);
+  EXPECT_CALL(mock_command_factory, CreateCommand(_, _))
+      .WillOnce(Return(rc_consent_request));
+  EXPECT_CALL(mock_hmi_interfaces_,
+              GetInterfaceFromFunction(
+                  hmi_apis::FunctionID::RC_GetInteriorVehicleDataConsent))
+      .WillOnce(Return(am::HmiInterfaces::HMI_INTERFACE_RC));
+
+  // Act
+  auto command = CreateRCCommand<commands::ButtonPressRequest>(mobile_message);
+  ASSERT_TRUE(command->Init());
+  command->Run();
+}
+
+TEST_F(RCGetInteriorVehicleDataConsentTest,
+       Run_MobileSendButtonPressMessage_HMISendINUSEModeToMobile) {
+  // Arrange
+  auto mobile_message = CreateBasicMessage();
+
+  // Expectations
+  EXPECT_CALL(mock_allocation_manager_, AcquireResource(_, _))
+      .WillOnce(Return(rc_rpc_plugin::AcquireResult::IN_USE));
+
+  EXPECT_CALL(*optional_mock_rpc_plugin, GetCommandFactory())
+      .WillOnce(ReturnRef(mock_command_factory));
+  auto rc_consent_response =
+      CreateRCCommand<commands::RCGetInteriorVehicleDataConsentResponse>(
+          mobile_message);
+  EXPECT_CALL(mock_command_factory, CreateCommand(_, _))
+      .WillOnce(Return(rc_consent_response));
+  auto command = CreateRCCommand<commands::ButtonPressRequest>(mobile_message);
+
+  // Act
+  ASSERT_TRUE(command->Init());
+  command->Run();
+}
+
+}  // namespace rc_rpc_plugin_test
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/set_interior_vehicle_data_request_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/set_interior_vehicle_data_request_test.cc
new file mode 100644
index 0000000000..68985e5f94
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/commands/set_interior_vehicle_data_request_test.cc
@@ -0,0 +1,225 @@
+/*
+ * 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 "application_manager/application.h"
+#include "application_manager/commands/command_request_test.h"
+#include "application_manager/mock_application.h"
+#include "rc_rpc_plugin/commands/mobile/set_interior_vehicle_data_request.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "rc_rpc_plugin/rc_module_constants.h"
+#include "rc_rpc_plugin/mock/mock_resource_allocation_manager.h"
+#include "gtest/gtest.h"
+#include "interfaces/MOBILE_API.h"
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::NiceMock;
+using application_manager::ApplicationSet;
+using application_manager::commands::MessageSharedPtr;
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockApplicationManager;
+using test::components::commands_test::CommandRequestTest;
+using test::components::commands_test::CommandsTestMocks;
+
+namespace {
+const uint32_t kAppId = 0u;
+const int kModuleId = 153u;
+const uint32_t kConnectionKey = 1u;
+const std::string kPolicyAppId = "Test";
+}
+
+namespace rc_rpc_plugin_test {
+using namespace rc_rpc_plugin;
+
+class SetInteriorVehicleDataRequestTest
+    : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SetInteriorVehicleDataRequestTest()
+      : mock_app_(utils::MakeShared<NiceMock<MockApplication> >())
+      , rc_app_extention_(utils::MakeShared<RCAppExtension>(kModuleId)) {}
+
+  void SetUp() OVERRIDE {
+    ON_CALL(app_mngr_, hmi_interfaces())
+        .WillByDefault(ReturnRef(mock_hmi_interfaces_));
+    ON_CALL(
+        mock_hmi_interfaces_,
+        GetInterfaceState(application_manager::HmiInterfaces::HMI_INTERFACE_RC))
+        .WillByDefault(Return(application_manager::HmiInterfaces::
+                                  InterfaceState::STATE_AVAILABLE));
+    ON_CALL(app_mngr_, application(kAppId)).WillByDefault(Return(mock_app_));
+    ON_CALL(mock_allocation_manager_, GetApplicationExtention(_))
+        .WillByDefault(Return(rc_app_extention_));
+
+    ON_CALL(*mock_app_, policy_app_id()).WillByDefault(Return(kPolicyAppId));
+    ON_CALL(mock_allocation_manager_, IsResourceFree(_))
+        .WillByDefault(Return(true));
+    ON_CALL(mock_allocation_manager_, AcquireResource(_, _))
+        .WillByDefault(Return(AcquireResult::ALLOWED));
+    ON_CALL(*mock_app_, app_id()).WillByDefault(Return(kAppId));
+    ON_CALL(mock_policy_handler_,
+            CheckHMIType(kPolicyAppId,
+                         mobile_apis::AppHMIType::eType::REMOTE_CONTROL,
+                         nullptr)).WillByDefault(Return(true));
+  }
+
+  MessageSharedPtr CreateBasicMessage() {
+    MessageSharedPtr message = CreateMessage();
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::function_id] =
+                  mobile_apis::FunctionID::SetInteriorVehicleDataID;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kConnectionKey;
+    (*message)[application_manager::strings::params]
+              [application_manager::strings::connection_key] = kAppId;
+    return message;
+  }
+
+  template <class Command>
+  application_manager::SharedPtr<Command> CreateRCCommand(
+      MessageSharedPtr& msg) {
+    InitCommand(kDefaultTimeout_);
+    return ::utils::MakeShared<Command>(msg ? msg : msg = CreateMessage(),
+                                        app_mngr_,
+                                        mock_rpc_service_,
+                                        mock_hmi_capabilities_,
+                                        mock_policy_handler_,
+                                        mock_allocation_manager_);
+  }
+
+ protected:
+  testing::NiceMock<rc_rpc_plugin_test::MockResourceAllocationManager>
+      mock_allocation_manager_;
+  utils::SharedPtr<MockApplication> mock_app_;
+  utils::SharedPtr<RCAppExtension> rc_app_extention_;
+};
+
+TEST_F(SetInteriorVehicleDataRequestTest,
+       Execute_ValidWithoutReadOnlyParams_ExpectResendToHMI) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleData][message_params::kModuleType] =
+      mobile_apis::ModuleType::CLIMATE;
+  msg_params[message_params::kModuleData][message_params::kClimateControlData] =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
+  // Expectations
+  EXPECT_CALL(mock_policy_handler_, CheckModule(kPolicyAppId, _))
+      .WillOnce(Return(rc_rpc_plugin::TypeAccess::kAllowed));
+
+  EXPECT_CALL(mock_hmi_capabilities_, rc_capability())
+      .WillOnce(Return(nullptr));
+
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(test::components::commands_test::MobileResultCodeIs(
+                              mobile_apis::Result::READ_ONLY),
+                          application_manager::commands::Command::SOURCE_SDL));
+  // Act
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::SetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::SetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->Run();
+}
+
+TEST_F(
+    SetInteriorVehicleDataRequestTest,
+    Execute_ValidWithSettableAndReadOnlyParams_ExpectCutReadOnlyAndResendToHMI) {
+  // Arrange
+
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleData][message_params::kModuleType] =
+      mobile_apis::ModuleType::RADIO;
+  smart_objects::SmartObject radio_control_data(smart_objects::SmartType_Map);
+  radio_control_data[message_params::kState] = true;
+  radio_control_data[message_params::kRadioEnable] = true;
+  msg_params[message_params::kModuleData][message_params::kRadioControlData] =
+      radio_control_data;
+
+  // Expectations
+  EXPECT_CALL(mock_policy_handler_, CheckModule(kPolicyAppId, _))
+      .WillOnce(Return(rc_rpc_plugin::TypeAccess::kAllowed));
+
+  EXPECT_CALL(mock_hmi_capabilities_, rc_capability())
+      .WillOnce(Return(nullptr));
+
+  EXPECT_CALL(app_mngr_, RemoveHMIFakeParameters(_));
+
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(test::components::commands_test::MobileResultCodeIs(
+                              mobile_apis::Result::OUT_OF_MEMORY),
+                          application_manager::commands::Command::SOURCE_SDL));
+
+  // Act
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::SetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::SetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->Run();
+}
+
+TEST_F(
+    SetInteriorVehicleDataRequestTest,
+    Execute_MessageValidationFailed_ExpectMessageNotSentToHMI_AndFalseSentToMobile) {
+  // Arrange
+  MessageSharedPtr mobile_message = CreateBasicMessage();
+  NsSmartDeviceLink::NsSmartObjects::SmartObject& msg_params =
+      (*mobile_message)[application_manager::strings::msg_params];
+  msg_params[message_params::kModuleData][message_params::kModuleType] =
+      mobile_apis::ModuleType::RADIO;
+
+  msg_params[message_params::kModuleData][message_params::kClimateControlData] =
+      smart_objects::SmartObject(smart_objects::SmartType_Map);
+
+  // Expectations
+  EXPECT_CALL(mock_policy_handler_, CheckModule(kPolicyAppId, _))
+      .WillOnce(Return(rc_rpc_plugin::TypeAccess::kAllowed));
+
+  EXPECT_CALL(
+      mock_rpc_service_,
+      ManageMobileCommand(test::components::commands_test::MobileResultCodeIs(
+                              mobile_apis::Result::INVALID_DATA),
+                          application_manager::commands::Command::SOURCE_SDL));
+
+  // Act
+  application_manager::SharedPtr<
+      rc_rpc_plugin::commands::SetInteriorVehicleDataRequest> command =
+      CreateRCCommand<rc_rpc_plugin::commands::SetInteriorVehicleDataRequest>(
+          mobile_message);
+  command->Run();
+}
+
+}  // namespace rc_rpc_plugin_test
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_resource_allocation_manager.h b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_resource_allocation_manager.h
new file mode 100644
index 0000000000..fb9326209c
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/include/rc_rpc_plugin/mock/mock_resource_allocation_manager.h
@@ -0,0 +1,72 @@
+/*
+ * 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_REMOTE_CONTROL_TEST_INCLUDE_MOCK_RESOURCE_ALLOCATION_MANAGER_H_
+#define SRC_COMPONENTS_REMOTE_CONTROL_TEST_INCLUDE_MOCK_RESOURCE_ALLOCATION_MANAGER_H_
+
+#include "gmock/gmock.h"
+#include "application_manager/rpc_plugins/rc_rpc_plugin/include/rc_rpc_plugin/resource_allocation_manager.h"
+
+namespace rc_rpc_plugin_test {
+
+class MockResourceAllocationManager
+    : public rc_rpc_plugin::ResourceAllocationManager {
+ public:
+  MOCK_METHOD2(AcquireResource,
+               rc_rpc_plugin::AcquireResult::eType(
+                   const std::string& module_type, const uint32_t app_id));
+  MOCK_METHOD2(ForceAcquireResource,
+               void(const std::string& module_type, const uint32_t app_id));
+  MOCK_METHOD2(OnDriverDisallowed,
+               void(const std::string& module_type, const uint32_t app_id));
+  MOCK_METHOD2(OnApplicationEvent,
+               void(application_manager::plugin_manager::ApplicationEvent event,
+                    application_manager::ApplicationSharedPtr application));
+  MOCK_METHOD1(OnPolicyEvent,
+               void(application_manager::plugin_manager::PolicyEvent event));
+  MOCK_METHOD1(SetAccessMode,
+               void(const hmi_apis::Common_RCAccessMode::eType access_mode));
+  MOCK_CONST_METHOD0(GetAccessMode, hmi_apis::Common_RCAccessMode::eType());
+  MOCK_METHOD3(SetResourceState,
+               void(const std::string& module_type,
+                    const uint32_t app_id,
+                    const rc_rpc_plugin::ResourceState::eType state));
+  MOCK_CONST_METHOD1(IsResourceFree, bool(const std::string& module_type));
+  MOCK_METHOD1(GetApplicationExtention,
+               rc_rpc_plugin::RCAppExtensionPtr(
+                   application_manager::ApplicationSharedPtr application));
+  MOCK_METHOD0(ResetAllAllocations, void());
+};
+
+}  // namespace rc_rpc_plugin_test
+
+#endif  // SRC_COMPONENTS_REMOTE_CONTROL_TEST_INCLUDE_MOCK_RESOURCE_ALLOCATION_MANAGER_H_
diff --git a/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/resource_allocation_manager_impl_test.cc b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/resource_allocation_manager_impl_test.cc
new file mode 100644
index 0000000000..26840a1b33
--- /dev/null
+++ b/src/components/application_manager/rpc_plugins/rc_rpc_plugin/test/resource_allocation_manager_impl_test.cc
@@ -0,0 +1,508 @@
+/*
+ * 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 <algorithm>
+#include "gtest/gtest.h"
+
+#include "rc_rpc_plugin/resource_allocation_manager_impl.h"
+#include "rc_rpc_plugin/rc_rpc_plugin.h"
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_rpc_service.h"
+#include "application_manager/policies/mock_policy_handler_interface.h"
+#include "utils/shared_ptr.h"
+#include "utils/make_shared.h"
+#include "interfaces/HMI_API.h"
+#include "interfaces/MOBILE_API.h"
+
+using test::components::application_manager_test::MockApplication;
+using test::components::application_manager_test::MockApplicationManager;
+using test::components::application_manager_test::MockRPCService;
+
+using ::testing::_;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::StrictMock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::SaveArg;
+using ::testing::Eq;
+using ::testing::DoAll;
+using ::testing::SetArgPointee;
+using ::application_manager::Message;
+using ::application_manager::MessageType;
+using ::application_manager::ApplicationSharedPtr;
+using ::protocol_handler::MessagePriority;
+
+namespace {
+const bool kDeviceHandle = 1u;
+const std::string kModuleType1 = "CLIMATE";
+const std::string kModuleType2 = "RADIO";
+const int32_t kConnectionKey = 5;
+const int32_t kCorrelationId = 5;
+const uint32_t kAppId1 = 11u;
+const uint32_t kAppId2 = 22u;
+const std::string policy_app_id_1_ = "policy_id_1";
+}
+
+namespace rc_rpc_plugin_test {
+
+using namespace rc_rpc_plugin;
+
+class RAManagerTest : public ::testing::Test {
+ public:
+  RAManagerTest()
+      : message_(utils::MakeShared<Message>(MessagePriority::FromServiceType(
+            protocol_handler::ServiceType::kRpc)))
+      , mock_app_1_(utils::MakeShared<NiceMock<MockApplication> >())
+      , mock_app_2_(utils::MakeShared<NiceMock<MockApplication> >())
+      , apps_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , apps_da_(apps_, apps_lock_ptr_) {
+    ON_CALL(mock_app_mngr_, GetPolicyHandler())
+        .WillByDefault(ReturnRef(mock_policy_handler_));
+    auto plugin_id = rc_rpc_plugin::RCRPCPlugin::kRCPluginID;
+    app_ext_ptr_ = utils::MakeShared<rc_rpc_plugin::RCAppExtension>(plugin_id);
+    ON_CALL(*mock_app_1_, app_id()).WillByDefault(Return(kAppId1));
+  }
+
+  void CheckResultWithHMILevelAndAccessMode(
+      ResourceAllocationManagerImpl& ra_manager,
+      mobile_apis::HMILevel::eType app_level,
+      const rc_rpc_plugin::AcquireResult::eType expected_result,
+      const hmi_apis::Common_RCAccessMode::eType access_mode);
+
+ protected:
+  NiceMock<MockApplicationManager> mock_app_mngr_;
+  NiceMock<MockRPCService> mock_rpc_service_;
+  test::components::policy_test::MockPolicyHandlerInterface
+      mock_policy_handler_;
+  application_manager::MessagePtr message_;
+
+  application_manager::AppExtensionPtr app_ext_ptr_;
+  utils::SharedPtr<NiceMock<MockApplication> > mock_app_1_;
+  utils::SharedPtr<NiceMock<MockApplication> > mock_app_2_;
+  application_manager::ApplicationSet apps_;
+  std::shared_ptr<sync_primitives::Lock> apps_lock_ptr_;
+  DataAccessor<application_manager::ApplicationSet> apps_da_;
+};
+
+void RAManagerTest::CheckResultWithHMILevelAndAccessMode(
+    ResourceAllocationManagerImpl& ra_manager,
+    mobile_apis::HMILevel::eType app_level,
+    const AcquireResult::eType expected_result,
+    const hmi_apis::Common_RCAccessMode::eType access_mode) {
+  // Arrange
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  ra_manager.SetAccessMode(access_mode);
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level()).WillOnce(Return(app_level));
+  // Second app tries to get already acquired resource by 1st app
+  EXPECT_EQ(expected_result, ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AcquireResource_NoAppRegistered_Expect_InUse) {
+  // Arrange
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(ApplicationSharedPtr()));
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  // Act & Assert
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+}
+
+TEST_F(RAManagerTest,
+       AcquireResource_AppRegisteredAnyHmiLevelResourceFree_Expect_Allowed) {
+  // Arrange
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  // Act & Assert
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_AppInAnyHmiLevelWantsToAcquireSameResourceTwice_Expect_Allowed) {
+  // Arrange
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  // Same app tries to get already acquired resource
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_NotInFULLWantsToGetAcquiredResource_Expect_Rejected) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_BACKGROUND;
+  const AcquireResult::eType expected_result = AcquireResult::REJECTED;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::AUTO_ALLOW;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_InFULLWantsToGetAcquiredResource_AUTO_DENY_Expect_InUse) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_FULL;
+  const AcquireResult::eType expected_result = AcquireResult::IN_USE;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::AUTO_DENY;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_InFULLWantsToGetAcquiredResource_AUTO_ALLOW_Expect_Allowed) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_FULL;
+  const AcquireResult::eType expected_result = AcquireResult::ALLOWED;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::AUTO_ALLOW;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(
+    RAManagerTest,
+    AcquireResource_App2_InFULLWantsToGetAcquiredResource_ASK_DRIVER_Expect_AskDriver) {
+  using namespace mobile_apis;
+  using namespace hmi_apis;
+  using namespace rc_rpc_plugin;
+  const HMILevel::eType app_level = HMILevel::eType::HMI_FULL;
+  const AcquireResult::eType expected_result = AcquireResult::ASK_DRIVER;
+  const Common_RCAccessMode::eType access_mode =
+      Common_RCAccessMode::eType::ASK_DRIVER;
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  CheckResultWithHMILevelAndAccessMode(
+      ra_manager, app_level, expected_result, access_mode);
+}
+
+TEST_F(RAManagerTest,
+       AcquireResource_AcquiredModuleIsRejectedForApp2_ExpectApp2Rejected) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+  EXPECT_EQ(AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  // Act
+  ra_manager.OnDriverDisallowed(kModuleType1, kAppId2);
+
+  // Assert
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_EQ(AcquireResult::REJECTED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AppExit_ReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_1_, QueryInterface(_))
+      .WillOnce(Return(rc_extention_ptr));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  // Act
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationExit, mock_app_1_);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AnotherAppExit_NoReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_2_, QueryInterface(_))
+      .WillOnce(Return(rc_extention_ptr));
+
+  // Act
+  application_manager::ApplicationSharedPtr app_ptr(mock_app_2_);
+  EXPECT_CALL(*mock_app_2_, app_id()).WillRepeatedly(Return(kAppId2));
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationExit, app_ptr);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillOnce(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AppUnregistered_ReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_1_, QueryInterface(_))
+      .WillOnce(Return(rc_extention_ptr));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  // Act
+  application_manager::ApplicationSharedPtr app_ptr(mock_app_1_);
+  EXPECT_CALL(*mock_app_1_, app_id()).WillRepeatedly(Return(kAppId1));
+
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationUnregistered, app_ptr);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AnotherAppUnregistered_NoReleaseResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillOnce(Return(mock_app_1_));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_2_));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_2_, QueryInterface(_))
+      .WillOnce(Return(rc_extention_ptr));
+
+  // Act
+  application_manager::ApplicationSharedPtr app_ptr(mock_app_2_);
+  EXPECT_CALL(*mock_app_2_, app_id()).WillRepeatedly(Return(kAppId2));
+
+  ra_manager.OnApplicationEvent(
+      application_manager::plugin_manager::kApplicationUnregistered, app_ptr);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillOnce(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillOnce(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+}
+
+TEST_F(RAManagerTest, AppsDisallowed_ReleaseAllResources) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId1));
+
+  application_manager::ApplicationSet apps;
+  apps.insert(mock_app_1_);
+  std::shared_ptr<sync_primitives::Lock> apps_lock =
+      std::make_shared<sync_primitives::Lock>();
+  DataAccessor<application_manager::ApplicationSet> apps_da(apps, apps_lock);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(apps_da));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<RCAppExtension>(application_manager::AppExtensionUID(
+          rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_1_, QueryInterface(RCRPCPlugin::kRCPluginID))
+      .WillRepeatedly(Return(rc_extention_ptr));
+
+  // Act
+  ra_manager.OnPolicyEvent(
+      application_manager::plugin_manager::PolicyEvent::kApplicationsDisabled);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId2));
+  Mock::VerifyAndClearExpectations(&mock_app_mngr_);
+}
+
+TEST_F(RAManagerTest, AppGotRevokedModulesWithPTU_ReleaseRevokedResource) {
+  // Arrange
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::eType::AUTO_DENY);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  RCAppExtensionPtr rc_extention_ptr =
+      utils::MakeShared<rc_rpc_plugin::RCAppExtension>(
+          application_manager::AppExtensionUID(
+              rc_rpc_plugin::RCRPCPlugin::kRCPluginID));
+
+  EXPECT_CALL(*mock_app_1_, QueryInterface(RCRPCPlugin::kRCPluginID))
+      .WillRepeatedly(Return(rc_extention_ptr));
+
+  ON_CALL(*mock_app_1_, is_remote_control_supported())
+      .WillByDefault(Return(true));
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId1))
+      .WillRepeatedly(Return(mock_app_1_));
+
+  EXPECT_CALL(*mock_app_1_, app_id()).WillRepeatedly(Return(kAppId1));
+
+  EXPECT_CALL(*mock_app_1_, policy_app_id())
+      .WillRepeatedly(Return(policy_app_id_1_));
+
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType1, kAppId1));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId1));
+
+  application_manager::ApplicationSet apps;
+  apps.insert(mock_app_1_);
+  std::shared_ptr<sync_primitives::Lock> apps_lock =
+      std::make_shared<sync_primitives::Lock>();
+  DataAccessor<application_manager::ApplicationSet> apps_da(apps, apps_lock);
+
+  EXPECT_CALL(mock_app_mngr_, applications()).WillRepeatedly(Return(apps_da));
+
+  Resources allowed_modules;
+  allowed_modules.push_back(kModuleType1);
+
+  EXPECT_CALL(mock_policy_handler_, GetModuleTypes(policy_app_id_1_, _))
+      .WillOnce(DoAll(SetArgPointee<1>(allowed_modules), Return(true)));
+
+  // Act
+  ra_manager.OnPolicyEvent(application_manager::plugin_manager::PolicyEvent::
+                               kApplicationPolicyUpdated);
+
+  EXPECT_CALL(mock_app_mngr_, application(kAppId2))
+      .WillRepeatedly(Return(mock_app_2_));
+  EXPECT_CALL(*mock_app_2_, hmi_level())
+      .WillRepeatedly(Return(mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::IN_USE,
+            ra_manager.AcquireResource(kModuleType1, kAppId2));
+  EXPECT_EQ(rc_rpc_plugin::AcquireResult::ALLOWED,
+            ra_manager.AcquireResource(kModuleType2, kAppId2));
+  Mock::VerifyAndClearExpectations(&mock_app_mngr_);
+}
+
+TEST_F(RAManagerTest, GetAccessMode_ExpectedSameAsHadSet) {
+  ResourceAllocationManagerImpl ra_manager(mock_app_mngr_, mock_rpc_service_);
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::AUTO_DENY);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::AUTO_DENY,
+            ra_manager.GetAccessMode());
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::ASK_DRIVER);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::ASK_DRIVER,
+            ra_manager.GetAccessMode());
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::AUTO_ALLOW);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::AUTO_ALLOW,
+            ra_manager.GetAccessMode());
+
+  ra_manager.SetAccessMode(hmi_apis::Common_RCAccessMode::INVALID_ENUM);
+  EXPECT_EQ(hmi_apis::Common_RCAccessMode::INVALID_ENUM,
+            ra_manager.GetAccessMode());
+}
+
+}  // namespace rc_rpc_plugin