Adds main logic and related bugfixes for transport switching

19 files changed, 490 insertions, 176 deletions

diff --git a/src/components/application_manager/include/application_manager/application.h b/src/components/application_manager/include/application_manager/application.h
index b753ba0e7f..63b8589b59 100644
--- a/src/components/application_manager/include/application_manager/application.h
+++ b/src/components/application_manager/include/application_manager/application.h
@@ -561,7 +561,6 @@ class Application : public virtual InitialApplicationData,
   virtual void increment_list_files_in_none_count() = 0;
   virtual bool set_app_icon_path(const std::string& file_name) = 0;
   virtual void set_app_allowed(const bool allowed) = 0;
-  virtual void set_device(connection_handler::DeviceHandle device) = 0;
   virtual uint32_t get_grammar_id() const = 0;
   virtual void set_grammar_id(uint32_t value) = 0;
 
@@ -618,6 +617,13 @@ class Application : public virtual InitialApplicationData,
   virtual UsageStatistics& usage_report() = 0;
 
   /**
+   * @brief SetInitialState sets initial HMI state for application on
+   * registration
+   * @param state Hmi state value
+   */
+  virtual void SetInitialState(HmiStatePtr state) = 0;
+
+  /**
    * @brief SetRegularState set permanent state of application
    *
    * @param state state to setup
@@ -764,16 +770,6 @@ class Application : public virtual InitialApplicationData,
   }
 
   /**
-   * @brief GetDeviceId allows to obtain device id which posseses
-   * by this application.
-   *
-   * @return device the device id.
-   */
-  std::string GetDeviceId() const {
-    return device_id_;
-  }
-
-  /**
    * @brief Returns is application should be greyed out on HMI
    */
   bool is_greyed_out() const {
@@ -861,7 +857,6 @@ class Application : public virtual InitialApplicationData,
   ApplicationState state_;
   std::string url_;
   std::string package_name_;
-  std::string device_id_;
   ssize_t connection_id_;
   bool is_greyed_out_;
 };
diff --git a/src/components/application_manager/include/application_manager/application_impl.h b/src/components/application_manager/include/application_manager/application_impl.h
index 01963e24e7..3c5353dfa2 100644
--- a/src/components/application_manager/include/application_manager/application_impl.h
+++ b/src/components/application_manager/include/application_manager/application_impl.h
@@ -65,6 +65,17 @@ using namespace timer;
 namespace mobile_api = mobile_apis;
 namespace custom_str = custom_string;
 
+/**
+ * @brief SwitchApplicationParameters updates application internal parameters
+ * on transport switch. Must be used only for switching flow.
+ * @param app Pointer to switched application
+ * @param app_id New application id (connection key)
+ * @param device_id New device id
+ */
+void SwitchApplicationParameters(ApplicationSharedPtr app,
+                                 const uint32_t app_id,
+                                 const uint32_t device_id);
+
 class ApplicationImpl : public virtual Application,
                         public virtual InitialApplicationDataImpl,
                         public virtual DynamicApplicationDataImpl {
@@ -73,6 +84,7 @@ class ApplicationImpl : public virtual Application,
       uint32_t application_id,
       const std::string& policy_app_id,
       const std::string& mac_address,
+      const connection_handler::DeviceHandle device_id,
       const custom_str::CustomString& app_name,
       utils::SharedPtr<usage_statistics::StatisticsManager> statistics_manager,
       ApplicationManager& application_manager);
@@ -161,7 +173,6 @@ class ApplicationImpl : public virtual Application,
   void increment_list_files_in_none_count();
   bool set_app_icon_path(const std::string& path);
   void set_app_allowed(const bool allowed);
-  void set_device(connection_handler::DeviceHandle device);
   virtual uint32_t get_grammar_id() const;
   virtual void set_grammar_id(uint32_t value);
   bool is_audio() const OVERRIDE;
@@ -250,6 +261,13 @@ class ApplicationImpl : public virtual Application,
   virtual bool IsAudioApplication() const;
 
   /**
+   * @brief SetInitialState sets initial HMI state for application on
+   * registration
+   * @param state Hmi state value
+   */
+  void SetInitialState(HmiStatePtr state) FINAL;
+
+  /**
   * @brief SetRegularState set permanent state of application
   *
   * @param state state to setup
@@ -442,6 +460,7 @@ class ApplicationImpl : public virtual Application,
   std::string app_icon_path_;
   connection_handler::DeviceHandle device_;
   const std::string mac_address_;
+  connection_handler::DeviceHandle device_id_;
   std::string bundle_id_;
   AppFilesMap app_files_;
   std::set<mobile_apis::ButtonName::eType> subscribed_buttons_;
@@ -486,6 +505,11 @@ class ApplicationImpl : public virtual Application,
   sync_primitives::Lock button_lock_;
   std::string folder_name_;
   ApplicationManager& application_manager_;
+
+  friend void SwitchApplicationParameters(ApplicationSharedPtr app,
+                                          const uint32_t app_id,
+                                          const uint32_t device_id);
+
   DISALLOW_COPY_AND_ASSIGN(ApplicationImpl);
 };
 
diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index a0b8d45de2..0e676f5f55 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -53,6 +53,7 @@
 #include "application_manager/application_manager_settings.h"
 #include "application_manager/event_engine/event_dispatcher_impl.h"
 #include "application_manager/hmi_interfaces_impl.h"
+#include "application_manager/command_holder.h"
 
 #include "protocol_handler/protocol_observer.h"
 #include "protocol_handler/protocol_handler.h"
@@ -500,7 +501,22 @@ class ApplicationManagerImpl
    */
   void SetAllAppsAllowed(const bool allowed) OVERRIDE;
 
+ /**
+   * @brief CreateRegularState create regular HMI state for application
+   * @param app Application
+   * @param hmi_level of returned state
+   * @param audio_state of returned state
+   * @param system_context of returned state
+   * @return new regular HMI state
+   */
+  HmiStatePtr CreateRegularState(
+      utils::SharedPtr<Application> app,
+      mobile_apis::HMILevel::eType hmi_level,
+      mobile_apis::AudioStreamingState::eType audio_state,
+      mobile_apis::SystemContext::eType system_context) const OVERRIDE;
+
   /**
+   * DEPRECATED
    * @brief CreateRegularState create regular HMI state for application
    * @param app_id
    * @param hmi_level of returned state
@@ -508,7 +524,7 @@ class ApplicationManagerImpl
    * @param system_context of returned state
    * @return new regular HMI state
    */
-  HmiStatePtr CreateRegularState(
+  DEPRECATED HmiStatePtr CreateRegularState(
       uint32_t app_id,
       mobile_apis::HMILevel::eType hmi_level,
       mobile_apis::AudioStreamingState::eType audio_state,
@@ -837,6 +853,10 @@ class ApplicationManagerImpl
   void OnFindNewApplicationsRequest() OVERRIDE;
   void RemoveDevice(
       const connection_handler::DeviceHandle& device_handle) OVERRIDE;
+  void OnDeviceSwitchingStart(const std::string& device_uid) FINAL;
+
+  void OnDeviceSwitchFinish(const std::string& device_uid) FINAL;
+  
   DEPRECATED bool OnServiceStartedCallback(
       const connection_handler::DeviceHandle& device_handle,
       const int32_t& session_key,
@@ -1212,11 +1232,25 @@ class ApplicationManagerImpl
   bool IsAppsQueriedFrom(
       const connection_handler::DeviceHandle handle) const OVERRIDE;
 
+  bool IsAppInReconnectMode(const std::string& policy_app_id) const FINAL;
+
   bool IsStopping() const OVERRIDE {
     return is_stopping_;
   }
 
   /**
+     * @brief ProcessReconnection handles reconnection flow for application on
+     * transport switch
+     * @param application Pointer to switched application, must be validated
+     * before passing
+     * @param connection_key Connection key from registration request of
+   * switched
+     * application
+     */
+  void ProcessReconnection(ApplicationSharedPtr application,
+                           const uint32_t connection_key) FINAL;
+
+  /**
    * @brief Clears all applications' persistent data
    */
   void ClearAppsPersistentData();
@@ -1401,7 +1435,7 @@ class ApplicationManagerImpl
    * @return True on success, false on fail
    */
   DEPRECATED bool StartNaviService(uint32_t app_id,
-                                   protocol_handler::ServiceType service_type);
+                        protocol_handler::ServiceType service_type);
 
   /**
    * @brief Starts specified navi service for application
@@ -1485,6 +1519,26 @@ class ApplicationManagerImpl
   void ClearTTSGlobalPropertiesList();
 
   /**
+   * @brief EraseAppFromReconnectionList drops application from reconnection
+   * list on transport switch success
+   * @param app Pointer to application
+   */
+  void EraseAppFromReconnectionList(const ApplicationSharedPtr& app);
+
+  /**
+   * @brief SwitchApplication updates parameters of switched application and
+   * internal applications list
+   * @param app Pointer to switched application, must be validated before
+   * passing in
+   * @param connection_key Connection key of switched application from its
+   * registration request
+   * @param device_id Device id of switched application
+   */
+  void SwitchApplication(ApplicationSharedPtr app,
+                         const uint32_t connection_key,
+                         const uint32_t device_id);
+
+  /**
    * @brief Converts BSON object containing video parameters to
    * smart object's map object
    * @param output the smart object to add video parameters
@@ -1617,6 +1671,11 @@ class ApplicationManagerImpl
   std::auto_ptr<app_launch::AppLaunchData> app_launch_dto_;
   std::auto_ptr<app_launch::AppLaunchCtrl> app_launch_ctrl_;
 
+  typedef std::vector<ApplicationSharedPtr> ReregisterWaitList;
+  ReregisterWaitList reregister_wait_list_;
+
+  mutable sync_primitives::Lock reregister_wait_list_lock_;
+
 #ifdef TELEMETRY_MONITOR
   AMTelemetryObserver* metric_observer_;
 #endif  // TELEMETRY_MONITOR
diff --git a/src/components/application_manager/include/application_manager/commands/command_impl.h b/src/components/application_manager/include/application_manager/commands/command_impl.h
index 66456dfdb1..7cab97d423 100644
--- a/src/components/application_manager/include/application_manager/commands/command_impl.h
+++ b/src/components/application_manager/include/application_manager/commands/command_impl.h
@@ -146,14 +146,14 @@ class CommandImpl : public Command {
    *
    * @param message Smartobject to be parsed
    */
-  void ReplaceMobileByHMIAppId(smart_objects::SmartObject& message);
+  bool ReplaceMobileByHMIAppId(smart_objects::SmartObject& message);
 
   /**
    * @brief Parse smartObject and replace HMI app ID by mobile app Id
    *
    * @param message Smartobject to be parsed
    */
-  void ReplaceHMIByMobileAppId(smart_objects::SmartObject& message);
+  bool ReplaceHMIByMobileAppId(smart_objects::SmartObject& message);
 
   MessageSharedPtr message_;
   uint32_t default_timeout_;
diff --git a/src/components/application_manager/include/application_manager/commands/hmi/on_app_unregistered_notification.h b/src/components/application_manager/include/application_manager/commands/hmi/on_app_unregistered_notification.h
index 980e558d6f..f49dac071f 100644
--- a/src/components/application_manager/include/application_manager/commands/hmi/on_app_unregistered_notification.h
+++ b/src/components/application_manager/include/application_manager/commands/hmi/on_app_unregistered_notification.h
@@ -55,12 +55,22 @@ class OnAppUnregisteredNotification : public NotificationToHMI {
   /**
    * @brief OnAppUnregisteredNotification class destructor
    **/
-  virtual ~OnAppUnregisteredNotification();
+  ~OnAppUnregisteredNotification() FINAL;
+
+  /**
+    * @brief Init overrides and skips replacement of app id with hmi id since
+    * 1) at the moment this notification is being sent there is no application
+    * registered in application manager
+    * 2) hmi id is already used whenever this message is being constructed, so
+    * its already there
+    * @return True in any case
+    */
+  bool Init() FINAL;
 
   /**
    * @brief Execute command
    **/
-  virtual void Run();
+  virtual void Run() FINAL;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OnAppUnregisteredNotification);
diff --git a/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h b/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h
index cc3d5b685c..369fd68868 100644
--- a/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h
+++ b/src/components/application_manager/include/application_manager/commands/mobile/register_app_interface_request.h
@@ -77,15 +77,17 @@ class RegisterAppInterfaceRequest : public CommandRequestImpl {
    **/
   virtual void Run();
 
+ private:
+  enum class AppicationType { kNewApplication, kSwitchedApplication };
+
   /**
    * @brief Sends RegisterAppInterface response to mobile
    *
    *@param application_impl application
    *
    **/
-  void SendRegisterAppInterfaceResponseToMobile();
+  void SendRegisterAppInterfaceResponseToMobile(AppicationType app_type);
 
- private:
   smart_objects::SmartObjectSPtr GetLockScreenIconUrlNotification(
       const uint32_t connection_key, ApplicationSharedPtr app);
 
@@ -184,6 +186,15 @@ class RegisterAppInterfaceRequest : public CommandRequestImpl {
    */
   void SendSubscribeCustomButtonNotification();
 
+  /**
+   * @brief IsApplicationSwitched checks whether application is switched from
+   * another transport. If application id is found, but not in reconnection
+   * list, returns 'already registered' code. Otherwise - proceed with
+   * switching.
+   * @return True if application is detected as switched, otherwise false.
+   */
+  bool IsApplicationSwitched();
+
  private:
   std::string response_info_;
   mobile_apis::Result::eType result_checking_app_hmi_type_;
diff --git a/src/components/application_manager/include/application_manager/hmi_state.h b/src/components/application_manager/include/application_manager/hmi_state.h
index 939b8b86d0..89c72370a5 100644
--- a/src/components/application_manager/include/application_manager/hmi_state.h
+++ b/src/components/application_manager/include/application_manager/hmi_state.h
@@ -41,6 +41,7 @@ namespace application_manager {
 
 class HmiState;
 class ApplicationManager;
+class Application;
 
 typedef utils::SharedPtr<HmiState> HmiStatePtr;
 
@@ -70,8 +71,9 @@ class HmiState {
     STATE_ID_EMBEDDED_NAVI
   };
 
-  HmiState(uint32_t app_id, const ApplicationManager& app_mngr);
-  HmiState(uint32_t app_id,
+  HmiState(utils::SharedPtr<Application> app,
+           const ApplicationManager& app_mngr);
+  HmiState(utils::SharedPtr<Application> app,
            const ApplicationManager& app_mngr,
            StateID state_id);
 
@@ -166,7 +168,7 @@ class HmiState {
   }
 
  protected:
-  uint32_t app_id_;
+  utils::SharedPtr<Application> app_;
   StateID state_id_;
   const ApplicationManager& app_mngr_;
   HmiStatePtr parent_;
@@ -177,26 +179,23 @@ class HmiState {
  protected:
   /**
    * @brief is_navi_app check if app is navi
-   * @param app_id application id
    * @return true if app is navi, otherwise return false
    */
-  bool is_navi_app(const uint32_t app_id) const;
+  bool is_navi_app() const;
 
   /**
    * @brief is_media_app check if app is media
-   * @param app_id application id
    * @return true if media_app, otherwise return false
    */
-  bool is_media_app(const uint32_t app_id) const;
+  bool is_media_app() const;
 
   /**
    * @brief is_voice_communicationn_app check if app is voice comunication
-   * @param app_id application id
    * @return true if voice_communicationn_app, otherwise return false
    */
-  bool is_voice_communication_app(const uint32_t app_id) const;
+  bool is_voice_communication_app() const;
 
-  bool is_mobile_projection_app(const uint32_t app_id) const;
+  bool is_mobile_projection_app() const;
 
  private:
   void operator=(const HmiState&);
@@ -209,7 +208,8 @@ class VRHmiState : public HmiState {
  public:
   virtual mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE;
-  VRHmiState(uint32_t app_id, const ApplicationManager& app_mngr);
+  VRHmiState(utils::SharedPtr<Application> app,
+             const ApplicationManager& app_mngr);
 };
 
 /**
@@ -217,7 +217,8 @@ class VRHmiState : public HmiState {
  */
 class TTSHmiState : public HmiState {
  public:
-  TTSHmiState(uint32_t app_id, const ApplicationManager& app_mngr);
+  TTSHmiState(utils::SharedPtr<Application> app,
+              const ApplicationManager& app_mngr);
   virtual mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE;
 };
@@ -228,7 +229,8 @@ class TTSHmiState : public HmiState {
  */
 class NaviStreamingHmiState : public HmiState {
  public:
-  NaviStreamingHmiState(uint32_t app_id, const ApplicationManager& app_mngr);
+  NaviStreamingHmiState(utils::SharedPtr<Application> app,
+                        const ApplicationManager& app_mngr);
   mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE;
 };
@@ -239,7 +241,8 @@ class NaviStreamingHmiState : public HmiState {
  */
 class PhoneCallHmiState : public HmiState {
  public:
-  PhoneCallHmiState(uint32_t app_id, const ApplicationManager& app_mngr);
+  PhoneCallHmiState(utils::SharedPtr<Application> app,
+                    const ApplicationManager& app_mngr);
   mobile_apis::HMILevel::eType hmi_level() const OVERRIDE;
   mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE {
@@ -253,7 +256,8 @@ class PhoneCallHmiState : public HmiState {
  */
 class SafetyModeHmiState : public HmiState {
  public:
-  SafetyModeHmiState(uint32_t app_id, const ApplicationManager& app_mngr);
+  SafetyModeHmiState(utils::SharedPtr<Application> app,
+                     const ApplicationManager& app_mngr);
   mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE {
     return mobile_apis::AudioStreamingState::NOT_AUDIBLE;
@@ -266,7 +270,8 @@ class SafetyModeHmiState : public HmiState {
  */
 class DeactivateHMI : public HmiState {
  public:
-  DeactivateHMI(uint32_t app_id, const ApplicationManager& app_mngr);
+  DeactivateHMI(utils::SharedPtr<Application> app,
+                const ApplicationManager& app_mngr);
   mobile_apis::HMILevel::eType hmi_level() const OVERRIDE;
   mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE {
@@ -280,7 +285,8 @@ class DeactivateHMI : public HmiState {
  */
 class AudioSource : public HmiState {
  public:
-  AudioSource(uint32_t app_id, const ApplicationManager& app_mngr);
+  AudioSource(utils::SharedPtr<Application> app,
+              const ApplicationManager& app_mngr);
   mobile_apis::HMILevel::eType hmi_level() const OVERRIDE;
   mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE {
@@ -295,7 +301,8 @@ class AudioSource : public HmiState {
  */
 class EmbeddedNavi : public HmiState {
  public:
-  EmbeddedNavi(uint32_t app_id, const ApplicationManager& app_mngr);
+  EmbeddedNavi(utils::SharedPtr<Application> app,
+               const ApplicationManager& app_mngr);
   mobile_apis::HMILevel::eType hmi_level() const OVERRIDE;
   mobile_apis::AudioStreamingState::eType audio_streaming_state()
       const OVERRIDE {
diff --git a/src/components/application_manager/include/application_manager/state_controller_impl.h b/src/components/application_manager/include/application_manager/state_controller_impl.h
index f2f9fb39a4..1b2033f5a8 100644
--- a/src/components/application_manager/include/application_manager/state_controller_impl.h
+++ b/src/components/application_manager/include/application_manager/state_controller_impl.h
@@ -289,7 +289,7 @@ class StateControllerImpl : public event_engine::EventObserver,
   void HMIStateStarted(ApplicationSharedPtr app) {
     DCHECK_OR_RETURN_VOID(app);
     HmiStatePtr old_hmi_state = app->CurrentHmiState();
-    HmiStatePtr new_hmi_state = CreateHmiState(app->app_id(), ID);
+    HmiStatePtr new_hmi_state = CreateHmiState(app, ID);
     DCHECK_OR_RETURN_VOID(new_hmi_state);
     DCHECK_OR_RETURN_VOID(new_hmi_state->state_id() !=
                           HmiState::STATE_ID_REGULAR);
@@ -326,7 +326,7 @@ class StateControllerImpl : public event_engine::EventObserver,
     DCHECK_OR_RETURN_VOID(app);
     HmiStatePtr cur = app->CurrentHmiState();
     HmiStatePtr old_hmi_state =
-        CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+        CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
     DCHECK_OR_RETURN_VOID(old_hmi_state);
     old_hmi_state->set_hmi_level(cur->hmi_level());
     old_hmi_state->set_audio_streaming_state(cur->audio_streaming_state());
@@ -431,7 +431,8 @@ class StateControllerImpl : public event_engine::EventObserver,
    * @param state_id state id
    * @return
    */
-  HmiStatePtr CreateHmiState(uint32_t app_id, HmiState::StateID state_id) const;
+  HmiStatePtr CreateHmiState(utils::SharedPtr<Application> app,
+                             HmiState::StateID state_id) const;
 
   mobile_apis::AudioStreamingState::eType CalcAudioState(
       ApplicationSharedPtr app,
diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc
index 0ba98d67f5..21847ffa1d 100644
--- a/src/components/application_manager/src/application_impl.cc
+++ b/src/components/application_manager/src/application_impl.cc
@@ -41,6 +41,7 @@
 #include "utils/file_system.h"
 #include "utils/logger.h"
 #include "utils/gen_hash.h"
+#include "utils/shared_ptr.h"
 #include "utils/make_shared.h"
 #include "utils/timer_task_impl.h"
 #include "application_manager/policies/policy_handler_interface.h"
@@ -76,10 +77,21 @@ CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager")
 
 namespace application_manager {
 
+void SwitchApplicationParameters(ApplicationSharedPtr app,
+                                 const uint32_t app_id,
+                                 const uint32_t device_id) {
+  utils::SharedPtr<ApplicationImpl> application =
+      ApplicationSharedPtr::dynamic_pointer_cast<ApplicationImpl>(app);
+  DCHECK_OR_RETURN_VOID(application);
+  application->app_id_ = app_id;
+  application->device_id_ = device_id;
+}
+
 ApplicationImpl::ApplicationImpl(
     uint32_t application_id,
     const std::string& mobile_app_id,
     const std::string& mac_address,
+    const connection_handler::DeviceHandle device_id,
     const custom_str::CustomString& app_name,
     utils::SharedPtr<usage_statistics::StatisticsManager> statistics_manager,
     ApplicationManager& application_manager)
@@ -107,6 +119,7 @@ ApplicationImpl::ApplicationImpl(
     , list_files_in_none_count_(0)
     , device_(0)
     , mac_address_(mac_address)
+    , device_id_(device_id)
     , usage_report_(mobile_app_id, statistics_manager)
     , protocol_version_(
           protocol_handler::MajorProtocolVersion::PROTOCOL_VERSION_3)
@@ -137,12 +150,6 @@ ApplicationImpl::ApplicationImpl(
   SubscribeToButton(mobile_apis::ButtonName::CUSTOM_BUTTON);
   // load persistent files
   LoadPersistentFiles();
-  HmiStatePtr initial_state = application_manager_.CreateRegularState(
-      app_id(),
-      mobile_apis::HMILevel::INVALID_ENUM,
-      mobile_apis::AudioStreamingState::INVALID_ENUM,
-      mobile_api::SystemContext::SYSCTXT_MAIN);
-  state_.InitState(initial_state);
 
   video_stream_suspend_timeout_ =
       application_manager_.get_settings().video_data_stopped_timeout();
@@ -347,7 +354,7 @@ const std::string& ApplicationImpl::bundle_id() const {
 }
 
 connection_handler::DeviceHandle ApplicationImpl::device() const {
-  return device_;
+  return device_id_;
 }
 
 const std::string& ApplicationImpl::mac_address() const {
@@ -606,10 +613,6 @@ void ApplicationImpl::set_app_allowed(const bool allowed) {
   is_app_allowed_ = allowed;
 }
 
-void ApplicationImpl::set_device(connection_handler::DeviceHandle device) {
-  device_ = device;
-}
-
 uint32_t ApplicationImpl::get_grammar_id() const {
   return grammar_id_;
 }
@@ -863,6 +866,10 @@ bool ApplicationImpl::is_application_data_changed() const {
   return is_application_data_changed_;
 }
 
+void ApplicationImpl::SetInitialState(HmiStatePtr state) {
+  state_.InitState(state);
+}
+
 void ApplicationImpl::set_is_application_data_changed(
     bool state_application_data) {
   is_application_data_changed_ = state_application_data;
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index b219635d46..65da6ed87e 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -93,9 +93,26 @@ DeviceTypes devicesType = {
                    hmi_apis::Common_TransportType::USB_IOS),
     std::make_pair(std::string("BLUETOOTH"),
                    hmi_apis::Common_TransportType::BLUETOOTH),
+    std::make_pair(std::string("IOS_BLUETOOTH"),
+                   hmi_apis::Common_TransportType::BLUETOOTH),
     std::make_pair(std::string("WIFI"), hmi_apis::Common_TransportType::WIFI)};
 }
 
+bool device_id_comparator(const std::string& device_id,
+                          ApplicationSharedPtr app) {
+  LOG4CXX_DEBUG(logger_,
+                "Data to compare: device_id : " << device_id << " app mac: "
+                                                << app->mac_address());
+
+  return device_id == app->mac_address();
+}
+
+bool policy_app_id_comparator(const std::string& policy_app_id,
+                              ApplicationSharedPtr app) {
+  DCHECK_OR_RETURN(app, false);
+  return app->policy_app_id() == policy_app_id;
+}
+
 uint32_t ApplicationManagerImpl::corelation_id_ = 0;
 const uint32_t ApplicationManagerImpl::max_corelation_id_ = UINT_MAX;
 
@@ -472,10 +489,10 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   // original app_id can be received via ApplicationImpl::mobile_app_id()
   uint32_t app_id = 0;
   std::list<int32_t> sessions_list;
-  uint32_t device_id = 0;
+  connection_handler::DeviceHandle device_id = 0;
 
   DCHECK_OR_RETURN(connection_handler_, ApplicationSharedPtr());
-  if (connection_handler().GetDataOnSessionKey(
+  if (connection_handler().get_session_observer().GetDataOnSessionKey(
           connection_key, &app_id, &sessions_list, &device_id) == -1) {
     LOG4CXX_ERROR(logger_, "Failed to create application: no connection info.");
     utils::SharedPtr<smart_objects::SmartObject> response(
@@ -488,6 +505,20 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
     return ApplicationSharedPtr();
   }
 
+  smart_objects::SmartObject& params = message[strings::msg_params];
+  const std::string& policy_app_id = params[strings::app_id].asString();
+  const custom_str::CustomString& app_name =
+      message[strings::msg_params][strings::app_name].asCustomString();
+  std::string device_mac;
+  std::string connection_type;
+  if (connection_handler().get_session_observer().GetDataOnDeviceID(
+          device_id, NULL, NULL, &device_mac, &connection_type) == -1) {
+    LOG4CXX_DEBUG(logger_, "Failed to extract device mac for id " << device_id);
+  } else {
+    LOG4CXX_DEBUG(logger_,
+                  "Device mac for id" << device_id << " is " << device_mac);
+  }
+
   LOG4CXX_DEBUG(logger_, "Restarting application list update timer");
   GetPolicyHandler().OnAppsSearchStarted();
   uint32_t timeout = get_settings().application_list_update_timeout();
@@ -506,22 +537,11 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
     return ApplicationSharedPtr();
   }
 
-  smart_objects::SmartObject& params = message[strings::msg_params];
-  const std::string& policy_app_id = params[strings::app_id].asString();
-  const custom_str::CustomString& app_name =
-      message[strings::msg_params][strings::app_name].asCustomString();
-  std::string device_mac = "";
-  if (connection_handler().get_session_observer().GetDataOnDeviceID(
-          device_id, NULL, NULL, &device_mac, NULL) == -1) {
-    LOG4CXX_ERROR(logger_, "Failed to extract device mac for id " << device_id);
-  } else {
-    LOG4CXX_DEBUG(logger_,
-                  "Device mac for id" << device_id << " is " << device_mac);
-  }
   ApplicationSharedPtr application(
       new ApplicationImpl(app_id,
                           policy_app_id,
                           device_mac,
+                          device_id,
                           app_name,
                           GetPolicyHandler().GetStatisticManager(),
                           *this));
@@ -536,12 +556,19 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
     return ApplicationSharedPtr();
   }
 
+  HmiStatePtr initial_state =
+      CreateRegularState(utils::SharedPtr<Application>(application),
+                         mobile_apis::HMILevel::INVALID_ENUM,
+                         mobile_apis::AudioStreamingState::INVALID_ENUM,
+                         mobile_api::SystemContext::SYSCTXT_MAIN);
+
+  application->SetInitialState(initial_state);
+
   application->set_folder_name(policy_app_id + "_" +
                                application->mac_address());
   // To load persistent files, app folder name must be known first, which is now
   // depends on device_id and mobile_app_id
   application->LoadPersistentFiles();
-  application->set_device(device_id);
 
   application->set_grammar_id(GenerateGrammarID());
   mobile_api::Language::eType launguage_desired =
@@ -788,11 +815,11 @@ void ApplicationManagerImpl::SetAllAppsAllowed(const bool allowed) {
 }
 
 HmiStatePtr ApplicationManagerImpl::CreateRegularState(
-    uint32_t app_id,
+    utils::SharedPtr<Application> app,
     mobile_apis::HMILevel::eType hmi_level,
     mobile_apis::AudioStreamingState::eType audio_state,
     mobile_apis::SystemContext::eType system_context) const {
-  HmiStatePtr state(new HmiState(app_id, *this));
+  HmiStatePtr state(new HmiState(app, *this));
   state->set_hmi_level(hmi_level);
   state->set_audio_streaming_state(audio_state);
   state->set_system_context(system_context);
@@ -1044,6 +1071,61 @@ void ApplicationManagerImpl::RemoveDevice(
   LOG4CXX_DEBUG(logger_, "device_handle " << device_handle);
 }
 
+void ApplicationManagerImpl::OnDeviceSwitchingStart(
+    const std::string& device_uid) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(reregister_wait_list_lock_);
+  auto apps_data_accessor = applications();
+
+  std::copy_if(apps_data_accessor.GetData().begin(),
+               apps_data_accessor.GetData().end(),
+               std::back_inserter(reregister_wait_list_),
+               std::bind1st(std::ptr_fun(&device_id_comparator), device_uid));
+}
+
+void ApplicationManagerImpl::OnDeviceSwitchFinish(
+    const std::string& device_uid) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  UNUSED(device_uid);
+  sync_primitives::AutoLock lock(reregister_wait_list_lock_);
+
+  const bool unexpected_disonnect = true;
+  const bool is_resuming = true;
+  for (auto app_it = reregister_wait_list_.begin();
+       app_it != reregister_wait_list_.end();
+       ++app_it) {
+    UnregisterApplication((*app_it)->app_id(),
+                          mobile_apis::Result::INVALID_ENUM,
+                          is_resuming,
+                          unexpected_disonnect);
+  }
+  reregister_wait_list_.clear();
+}
+
+void ApplicationManagerImpl::SwitchApplication(ApplicationSharedPtr app,
+                                               const uint32_t connection_key,
+                                               const uint32_t device_id) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(applications_list_lock_);
+  DCHECK_OR_RETURN_VOID(1 == applications_.erase(app));
+
+  LOG4CXX_DEBUG(logger_,
+                "Changing app id to " << connection_key
+                                      << ". Changing device id to "
+                                      << device_id);
+
+  SwitchApplicationParameters(app, connection_key, device_id);
+
+  // Normally this is done during registration, however since switched apps are
+  // not being registered again need to set protocol version on session.
+  connection_handler().BindProtocolVersionWithSession(
+      connection_key, static_cast<uint8_t>(app->protocol_version()));
+
+  // Application need to be re-inserted in order to keep sorting in applications
+  // container. Otherwise data loss on erasing is possible.
+  applications_.insert(app);
+}
+
 mobile_apis::HMILevel::eType ApplicationManagerImpl::GetDefaultHmiLevel(
     ApplicationConstSharedPtr application) const {
   using namespace mobile_apis;
@@ -2589,10 +2671,10 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
     const std::string app_icon_dir(settings_.app_icons_folder());
     const std::string full_icon_path(app_icon_dir + "/" + policy_app_id);
 
-    uint32_t device_id = 0;
+    connection_handler::DeviceHandle device_id = 0;
 
     if (-1 ==
-        connection_handler().GetDataOnSessionKey(
+        connection_handler().get_session_observer().GetDataOnSessionKey(
             connection_key, NULL, NULL, &device_id)) {
       LOG4CXX_ERROR(logger_,
                     "Failed to create application: no connection info.");
@@ -2614,6 +2696,7 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
         new ApplicationImpl(0,
                             policy_app_id,
                             device_mac,
+                            device_id,
                             appName,
                             GetPolicyHandler().GetStatisticManager(),
                             *this));
@@ -2622,7 +2705,6 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
     app->SetPackageName(package_name);
     app->set_app_icon_path(full_icon_path);
     app->set_hmi_application_id(hmi_app_id);
-    app->set_device(device_id);
 
     app->set_vr_synonyms(vrSynonym);
     app->set_tts_name(ttsName);
@@ -2977,13 +3059,14 @@ void ApplicationManagerImpl::UnregisterApplication(
   ApplicationSharedPtr app_to_remove;
   connection_handler::DeviceHandle handle = 0;
   {
-    DataAccessor<ApplicationSet> accessor(applications());
-    ApplicationSetConstIt it = accessor.GetData().begin();
-    for (; it != accessor.GetData().end(); ++it) {
-      if ((*it)->app_id() == app_id) {
-        app_to_remove = *it;
-        handle = app_to_remove->device();
-        break;
+    sync_primitives::AutoLock lock(applications_list_lock_);
+    auto it_app = applications_.begin();
+    while (applications_.end() != it_app) {
+      if (app_id == (*it_app)->app_id()) {
+        app_to_remove = *it_app;
+        applications_.erase(it_app++);
+      } else {
+        ++it_app;
       }
     }
     if (!app_to_remove) {
@@ -3001,11 +3084,10 @@ void ApplicationManagerImpl::UnregisterApplication(
     } else {
       resume_controller().RemoveApplicationFromSaved(app_to_remove);
     }
-    applications_.erase(app_to_remove);
     (hmi_capabilities_->get_hmi_language_handler())
         .OnUnregisterApplication(app_id);
     AppV4DevicePredicate finder(handle);
-    ApplicationSharedPtr app = FindApp(accessor, finder);
+    ApplicationSharedPtr app = FindApp(applications(), finder);
     if (!app) {
       LOG4CXX_DEBUG(
           logger_, "There is no more SDL4 apps with device handle: " << handle);
@@ -3236,8 +3318,9 @@ bool ApplicationManagerImpl::IsLowVoltage() {
 
 std::string ApplicationManagerImpl::GetHashedAppID(
     uint32_t connection_key, const std::string& mobile_app_id) const {
-  uint32_t device_id = 0;
-  connection_handler().GetDataOnSessionKey(connection_key, 0, NULL, &device_id);
+  connection_handler::DeviceHandle device_id = 0;
+  connection_handler().get_session_observer().GetDataOnSessionKey(
+      connection_key, 0, NULL, &device_id);
   std::string device_name;
   connection_handler().get_session_observer().GetDataOnDeviceID(
       device_id, &device_name, NULL, NULL, NULL);
@@ -3598,6 +3681,18 @@ bool ApplicationManagerImpl::IsApplicationForbidden(
   return forbidden_applications.find(name) != forbidden_applications.end();
 }
 
+// TODO: check its usage
+bool ApplicationManagerImpl::IsAppInReconnectMode(
+    const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(reregister_wait_list_lock_);
+  return reregister_wait_list_.end() !=
+         std::find_if(reregister_wait_list_.begin(),
+                      reregister_wait_list_.end(),
+                      std::bind1st(std::ptr_fun(&policy_app_id_comparator),
+                                   policy_app_id));
+}
+
 policy::DeviceConsent ApplicationManagerImpl::GetUserConsentForDevice(
     const std::string& device_id) const {
   return GetPolicyHandler().GetUserConsentForDevice(device_id);
@@ -3881,6 +3976,52 @@ void ApplicationManagerImpl::OnUpdateHMIAppType(
   }
 }
 
+void ApplicationManagerImpl::EraseAppFromReconnectionList(
+    const ApplicationSharedPtr& app) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (!app) {
+    LOG4CXX_WARN(logger_, "Application is not valid.");
+    return;
+  }
+
+  const auto policy_app_id = app->policy_app_id();
+  sync_primitives::AutoLock lock(reregister_wait_list_lock_);
+  auto app_it = std::find_if(
+      reregister_wait_list_.begin(),
+      reregister_wait_list_.end(),
+      std::bind1st(std::ptr_fun(&policy_app_id_comparator), policy_app_id));
+  if (reregister_wait_list_.end() != app_it) {
+    reregister_wait_list_.erase(app_it);
+  }
+}
+
+void ApplicationManagerImpl::ProcessReconnection(
+    ApplicationSharedPtr application, const uint32_t connection_key) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  DCHECK_OR_RETURN_VOID(application);
+
+  connection_handler::DeviceHandle new_device_id = 0;
+  connection_handler().get_session_observer().GetDataOnSessionKey(
+      connection_key, NULL, NULL, &new_device_id);
+  DCHECK_OR_RETURN_VOID(new_device_id);
+
+  std::string device_mac;
+  std::string connection_type;
+  connection_handler().get_session_observer().GetDataOnDeviceID(
+      new_device_id, NULL, NULL, &device_mac, &connection_type);
+
+  DCHECK_OR_RETURN_VOID(application->mac_address() == device_mac);
+
+  EraseAppFromReconnectionList(application);
+
+  connection_handler().OnDeviceConnectionSwitched(device_mac);
+
+  SwitchApplication(application, connection_key, new_device_id);
+
+  // Update connection type for existed device.
+  GetPolicyHandler().AddDevice(device_mac, connection_type);
+}
+
 void ApplicationManagerImpl::OnPTUFinished(const bool ptu_result) {
 #ifdef SDL_REMOTE_CONTROL
   if (!ptu_result) {
diff --git a/src/components/application_manager/src/commands/command_impl.cc b/src/components/application_manager/src/commands/command_impl.cc
index 0a3e65a790..d17f6cdc10 100644
--- a/src/components/application_manager/src/commands/command_impl.cc
+++ b/src/components/application_manager/src/commands/command_impl.cc
@@ -94,18 +94,20 @@ void CommandImpl::SetAllowedToTerminate(const bool allowed) {
   allowed_to_terminate_ = allowed;
 }
 
-void CommandImpl::ReplaceMobileByHMIAppId(
+bool CommandImpl::ReplaceMobileByHMIAppId(
     NsSmartDeviceLink::NsSmartObjects::SmartObject& message) {
   if (message.keyExists(strings::app_id)) {
     ApplicationSharedPtr application =
         application_manager_.application(message[strings::app_id].asUInt());
-    if (application.valid()) {
-      LOG4CXX_DEBUG(logger_,
-                    "ReplaceMobileByHMIAppId from "
-                        << message[strings::app_id].asInt() << " to "
-                        << application->hmi_app_id());
-      message[strings::app_id] = application->hmi_app_id();
+    if (!application) {
+      LOG4CXX_ERROR(logger_, "Substitution mobile --> HMI id is failed.");
+      return false;
     }
+    LOG4CXX_DEBUG(logger_,
+                  "ReplaceMobileByHMIAppId from "
+                      << message[strings::app_id].asInt() << " to "
+                      << application->hmi_app_id());
+    message[strings::app_id] = application->hmi_app_id();
   } else {
     switch (message.getType()) {
       case smart_objects::SmartType::SmartType_Array: {
@@ -128,22 +130,26 @@ void CommandImpl::ReplaceMobileByHMIAppId(
       default: { break; }
     }
   }
+
+  return true;
 }
 
-void CommandImpl::ReplaceHMIByMobileAppId(
+bool CommandImpl::ReplaceHMIByMobileAppId(
     NsSmartDeviceLink::NsSmartObjects::SmartObject& message) {
   if (message.keyExists(strings::app_id)) {
     ApplicationSharedPtr application =
         application_manager_.application_by_hmi_app(
             message[strings::app_id].asUInt());
 
-    if (application.valid()) {
-      LOG4CXX_DEBUG(logger_,
-                    "ReplaceHMIByMobileAppId from "
-                        << message[strings::app_id].asInt() << " to "
-                        << application->app_id());
-      message[strings::app_id] = application->app_id();
+    if (!application) {
+      LOG4CXX_ERROR(logger_, "Substitution HMI --> mobile id is failed.");
+      return false;
     }
+    LOG4CXX_DEBUG(logger_,
+                  "ReplaceHMIByMobileAppId from "
+                      << message[strings::app_id].asInt() << " to "
+                      << application->app_id());
+    message[strings::app_id] = application->app_id();
   } else {
     switch (message.getType()) {
       case smart_objects::SmartType::SmartType_Array: {
@@ -165,6 +171,8 @@ void CommandImpl::ReplaceHMIByMobileAppId(
       default: { break; }
     }
   }
+
+  return true;
 }
 
 }  // namespace commands
diff --git a/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc b/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc
index f1e933b7ef..7e24dce8d9 100644
--- a/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc
+++ b/src/components/application_manager/src/commands/hmi/notification_to_hmi.cc
@@ -39,15 +39,12 @@ namespace commands {
 
 NotificationToHMI::NotificationToHMI(const MessageSharedPtr& message,
                                      ApplicationManager& application_manager)
-    : CommandImpl(message, application_manager) {
-  // Replace Mobile connection id with HMI app id
-  ReplaceMobileByHMIAppId(*(message.get()));
-}
+    : CommandImpl(message, application_manager) {}
 
 NotificationToHMI::~NotificationToHMI() {}
 
 bool NotificationToHMI::Init() {
-  return true;
+  return ReplaceMobileByHMIAppId(*message_);
 }
 
 bool NotificationToHMI::CleanUp() {
diff --git a/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc b/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc
index 10ea1ea303..f64e3e111b 100644
--- a/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc
+++ b/src/components/application_manager/src/commands/hmi/on_app_unregistered_notification.cc
@@ -44,6 +44,12 @@ OnAppUnregisteredNotification::OnAppUnregisteredNotification(
 
 OnAppUnregisteredNotification::~OnAppUnregisteredNotification() {}
 
+bool OnAppUnregisteredNotification::Init() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  LOG4CXX_DEBUG(logger_, "Replacement of hmi id is skipped.");
+  return true;
+}
+
 void OnAppUnregisteredNotification::Run() {
   LOG4CXX_AUTO_TRACE(logger_);
 
diff --git a/src/components/application_manager/src/commands/hmi/request_to_hmi.cc b/src/components/application_manager/src/commands/hmi/request_to_hmi.cc
index 39d549ac72..f26dc26ef6 100644
--- a/src/components/application_manager/src/commands/hmi/request_to_hmi.cc
+++ b/src/components/application_manager/src/commands/hmi/request_to_hmi.cc
@@ -61,15 +61,12 @@ bool ChangeInterfaceState(ApplicationManager& application_manager,
 
 RequestToHMI::RequestToHMI(const MessageSharedPtr& message,
                            ApplicationManager& application_manager)
-    : CommandImpl(message, application_manager) {
-  // Replace Mobile connection id with HMI app id
-  ReplaceMobileByHMIAppId(*(message.get()));
-}
+    : CommandImpl(message, application_manager) {}
 
 RequestToHMI::~RequestToHMI() {}
 
 bool RequestToHMI::Init() {
-  return true;
+  return ReplaceMobileByHMIAppId(*message_);
 }
 
 bool RequestToHMI::CleanUp() {
diff --git a/src/components/application_manager/src/commands/hmi/response_to_hmi.cc b/src/components/application_manager/src/commands/hmi/response_to_hmi.cc
index e6f64047ba..77e523378a 100644
--- a/src/components/application_manager/src/commands/hmi/response_to_hmi.cc
+++ b/src/components/application_manager/src/commands/hmi/response_to_hmi.cc
@@ -39,15 +39,12 @@ namespace commands {
 
 ResponseToHMI::ResponseToHMI(const MessageSharedPtr& message,
                              ApplicationManager& application_manager)
-    : CommandImpl(message, application_manager) {
-  // Replace Mobile connection id with HMI app id
-  ReplaceMobileByHMIAppId(*(message.get()));
-}
+    : CommandImpl(message, application_manager) {}
 
 ResponseToHMI::~ResponseToHMI() {}
 
 bool ResponseToHMI::Init() {
-  return true;
+  return ReplaceMobileByHMIAppId(*message_);
 }
 
 bool ResponseToHMI::CleanUp() {
diff --git a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
index 1a60537874..1939150541 100644
--- a/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
+++ b/src/components/application_manager/src/commands/mobile/register_app_interface_request.cc
@@ -217,6 +217,13 @@ void RegisterAppInterfaceRequest::Run() {
     return;
   }
 
+  if (IsApplicationSwitched()) {
+    return;
+  }
+
+  const std::string mobile_app_id =
+      (*message_)[strings::msg_params][strings::app_id].asString();
+
   ApplicationSharedPtr application =
       application_manager_.application(connection_key());
 
@@ -362,7 +369,7 @@ void RegisterAppInterfaceRequest::Run() {
 
   GetPolicyHandler().SetDeviceInfo(device_mac, device_info);
 
-  SendRegisterAppInterfaceResponseToMobile();
+  SendRegisterAppInterfaceResponseToMobile(AppicationType::kNewApplication);
   smart_objects::SmartObjectSPtr so =
       GetLockScreenIconUrlNotification(connection_key(), application);
   application_manager_.ManageMobileCommand(so, commands::Command::ORIGIN_SDL);
@@ -501,7 +508,8 @@ void FillUIRelatedFields(smart_objects::SmartObject& response_params,
       hmi_capabilities.rc_supported();
 }
 
-void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile() {
+void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile(
+    AppicationType app_type) {
   LOG4CXX_AUTO_TRACE(logger_);
   smart_objects::SmartObject response_params(smart_objects::SmartType_Map);
 
@@ -631,6 +639,14 @@ void RegisterAppInterfaceRequest::SendRegisterAppInterfaceResponseToMobile() {
     response_params[strings::system_software_version] = ccpu_version;
   }
 
+  if (AppicationType::kSwitchedApplication == app_type) {
+    LOG4CXX_DEBUG(logger_,
+                  "Application has been switched from another transport.");
+
+    SendResponse(true, result_code, NULL, &response_params);
+    return;
+  }
+
   bool resumption =
       (*message_)[strings::msg_params].keyExists(strings::hash_id);
 
@@ -1194,6 +1210,43 @@ void RegisterAppInterfaceRequest::SendSubscribeCustomButtonNotification() {
   CreateHMINotification(FunctionID::Buttons_OnButtonSubscription, msg_params);
 }
 
+bool RegisterAppInterfaceRequest::IsApplicationSwitched() {
+  const smart_objects::SmartObject& msg_params =
+      (*message_)[strings::msg_params];
+
+  const std::string& policy_app_id = msg_params[strings::app_id].asString();
+
+  LOG4CXX_DEBUG(logger_, "Looking for application id " << policy_app_id);
+
+  auto app = application_manager_.application_by_policy_id(policy_app_id);
+
+  if (!app) {
+    LOG4CXX_DEBUG(logger_,
+                  "Application with policy id " << policy_app_id
+                                                << " is not found.");
+    return false;
+  }
+
+  LOG4CXX_DEBUG(logger_,
+                "Application with policy id " << policy_app_id << " is found.");
+  if (!application_manager_.IsAppInReconnectMode(policy_app_id)) {
+    LOG4CXX_DEBUG(logger_,
+                  "Policy id " << policy_app_id
+                               << " is not found in reconnection list.");
+    SendResponse(false, mobile_apis::Result::APPLICATION_REGISTERED_ALREADY);
+    return false;
+  }
+
+  LOG4CXX_DEBUG(logger_, "Application is found in reconnection list.");
+  application_manager_.ProcessReconnection(app, connection_key());
+  SendRegisterAppInterfaceResponseToMobile(
+      AppicationType::kSwitchedApplication);
+
+  application_manager_.SendHMIStatusNotification(app);
+
+  return true;
+}
+
 policy::PolicyHandlerInterface&
 RegisterAppInterfaceRequest::GetPolicyHandler() {
   return application_manager_.GetPolicyHandler();
diff --git a/src/components/application_manager/src/hmi_state.cc b/src/components/application_manager/src/hmi_state.cc
index 393a9d7784..d31ff364ea 100644
--- a/src/components/application_manager/src/hmi_state.cc
+++ b/src/components/application_manager/src/hmi_state.cc
@@ -37,18 +37,19 @@
 
 namespace application_manager {
 
-HmiState::HmiState(uint32_t app_id,
+HmiState::HmiState(utils::SharedPtr<Application> app,
                    const ApplicationManager& app_mngr,
                    StateID state_id)
-    : app_id_(app_id)
+    : app_(app)
     , state_id_(state_id)
     , app_mngr_(app_mngr)
     , hmi_level_(mobile_apis::HMILevel::INVALID_ENUM)
     , audio_streaming_state_(mobile_apis::AudioStreamingState::INVALID_ENUM)
     , system_context_(mobile_apis::SystemContext::INVALID_ENUM) {}
 
-HmiState::HmiState(uint32_t app_id, const ApplicationManager& app_mngr)
-    : app_id_(app_id)
+HmiState::HmiState(utils::SharedPtr<Application> app,
+                   const ApplicationManager& app_mngr)
+    : app_(app)
     , state_id_(STATE_ID_REGULAR)
     , app_mngr_(app_mngr)
     , hmi_level_(mobile_apis::HMILevel::INVALID_ENUM)
@@ -60,24 +61,20 @@ void HmiState::set_parent(HmiStatePtr parent) {
   parent_ = parent;
 }
 
-bool HmiState::is_navi_app(const uint32_t app_id) const {
-  const ApplicationSharedPtr app = app_mngr_.application(app_id);
-  return app ? app->is_navi() : false;
+bool HmiState::is_navi_app() const {
+  return app_->is_navi();
 }
 
-bool HmiState::is_media_app(const uint32_t app_id) const {
-  const ApplicationSharedPtr app = app_mngr_.application(app_id);
-  return app ? app->is_media_application() : false;
+bool HmiState::is_media_app() const {
+  return app_->is_media_application();
 }
 
-bool HmiState::is_voice_communication_app(const uint32_t app_id) const {
-  const ApplicationSharedPtr app = app_mngr_.application(app_id);
-  return app ? app->is_voice_communication_supported() : false;
+bool HmiState::is_voice_communication_app() const {
+  return app_->is_voice_communication_supported();
 }
 
-bool HmiState::is_mobile_projection_app(const uint32_t app_id) const {
-  const ApplicationSharedPtr app = app_mngr_.application(app_id);
-  return app ? app->mobile_projection_enabled() : false;
+bool HmiState::is_mobile_projection_app() const {
+  return app_->mobile_projection_enabled();
 }
 
 mobile_apis::AudioStreamingState::eType VRHmiState::audio_streaming_state()
@@ -86,11 +83,13 @@ mobile_apis::AudioStreamingState::eType VRHmiState::audio_streaming_state()
   return AudioStreamingState::NOT_AUDIBLE;
 }
 
-VRHmiState::VRHmiState(uint32_t app_id, const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_VR_SESSION) {}
+VRHmiState::VRHmiState(utils::SharedPtr<Application> app,
+                       const ApplicationManager& app_mngr)
+    : HmiState(app, app_mngr, STATE_ID_VR_SESSION) {}
 
-TTSHmiState::TTSHmiState(uint32_t app_id, const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_TTS_SESSION) {}
+TTSHmiState::TTSHmiState(utils::SharedPtr<Application> app,
+                         const ApplicationManager& app_mngr)
+    : HmiState(app, app_mngr, STATE_ID_TTS_SESSION) {}
 
 mobile_apis::AudioStreamingState::eType TTSHmiState::audio_streaming_state()
     const {
@@ -107,9 +106,9 @@ mobile_apis::AudioStreamingState::eType TTSHmiState::audio_streaming_state()
   return expected_state;
 }
 
-NaviStreamingHmiState::NaviStreamingHmiState(uint32_t app_id,
+NaviStreamingHmiState::NaviStreamingHmiState(utils::SharedPtr<Application> app,
                                              const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_NAVI_STREAMING) {}
+    : HmiState(app, app_mngr, STATE_ID_NAVI_STREAMING) {}
 
 mobile_apis::AudioStreamingState::eType
 NaviStreamingHmiState::audio_streaming_state() const {
@@ -117,7 +116,7 @@ NaviStreamingHmiState::audio_streaming_state() const {
   using namespace mobile_apis;
 
   AudioStreamingState::eType expected_state = parent()->audio_streaming_state();
-  if (!is_navi_app(app_id_) && AudioStreamingState::AUDIBLE == expected_state) {
+  if (!is_navi_app() && AudioStreamingState::AUDIBLE == expected_state) {
     if (app_mngr_.is_attenuated_supported()) {
       expected_state = AudioStreamingState::ATTENUATED;
     } else {
@@ -127,9 +126,9 @@ NaviStreamingHmiState::audio_streaming_state() const {
   return expected_state;
 }
 
-PhoneCallHmiState::PhoneCallHmiState(uint32_t app_id,
+PhoneCallHmiState::PhoneCallHmiState(utils::SharedPtr<Application> app,
                                      const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_PHONE_CALL) {}
+    : HmiState(app, app_mngr, STATE_ID_PHONE_CALL) {}
 
 mobile_apis::HMILevel::eType PhoneCallHmiState::hmi_level() const {
   using namespace helpers;
@@ -139,22 +138,22 @@ mobile_apis::HMILevel::eType PhoneCallHmiState::hmi_level() const {
                                         HMILevel::HMI_NONE)) {
     return parent()->hmi_level();
   }
-  if (is_navi_app(app_id_) || is_mobile_projection_app(app_id_)) {
+  if (is_navi_app() || is_mobile_projection_app()) {
     return HMILevel::HMI_LIMITED;
   }
-  if (!is_media_app(app_id_)) {
+  if (!is_media_app()) {
     return parent()->hmi_level();
   }
   return HMILevel::HMI_BACKGROUND;
 }
 
-SafetyModeHmiState::SafetyModeHmiState(uint32_t app_id,
+SafetyModeHmiState::SafetyModeHmiState(utils::SharedPtr<Application> app,
                                        const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_SAFETY_MODE) {}
+    : HmiState(app, app_mngr, STATE_ID_SAFETY_MODE) {}
 
-DeactivateHMI::DeactivateHMI(uint32_t app_id,
+DeactivateHMI::DeactivateHMI(utils::SharedPtr<Application> app,
                              const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_DEACTIVATE_HMI) {}
+    : HmiState(app, app_mngr, STATE_ID_DEACTIVATE_HMI) {}
 
 mobile_apis::HMILevel::eType DeactivateHMI::hmi_level() const {
   using namespace helpers;
@@ -167,8 +166,9 @@ mobile_apis::HMILevel::eType DeactivateHMI::hmi_level() const {
   return HMILevel::HMI_BACKGROUND;
 }
 
-AudioSource::AudioSource(uint32_t app_id, const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_AUDIO_SOURCE) {}
+AudioSource::AudioSource(utils::SharedPtr<Application> app,
+                         const ApplicationManager& app_mngr)
+    : HmiState(app, app_mngr, STATE_ID_AUDIO_SOURCE) {}
 
 mobile_apis::HMILevel::eType AudioSource::hmi_level() const {
   using namespace mobile_apis;
@@ -181,14 +181,15 @@ mobile_apis::HMILevel::eType AudioSource::hmi_level() const {
                                         HMILevel::HMI_NONE)) {
     return parent()->hmi_level();
   }
-  if (is_navi_app(app_id_) || is_voice_communication_app(app_id_)) {
+  if (is_navi_app() || is_voice_communication_app()) {
     return HMILevel::HMI_LIMITED;
   }
   return HMILevel::HMI_BACKGROUND;
 }
 
-EmbeddedNavi::EmbeddedNavi(uint32_t app_id, const ApplicationManager& app_mngr)
-    : HmiState(app_id, app_mngr, STATE_ID_EMBEDDED_NAVI) {}
+EmbeddedNavi::EmbeddedNavi(utils::SharedPtr<Application> app,
+                           const ApplicationManager& app_mngr)
+    : HmiState(app, app_mngr, STATE_ID_EMBEDDED_NAVI) {}
 
 mobile_apis::HMILevel::eType EmbeddedNavi::hmi_level() const {
   using namespace mobile_apis;
@@ -198,7 +199,7 @@ mobile_apis::HMILevel::eType EmbeddedNavi::hmi_level() const {
                                         HMILevel::HMI_NONE)) {
     return parent()->hmi_level();
   }
-  if (is_media_app(app_id_)) {
+  if (is_media_app()) {
     return HMILevel::HMI_LIMITED;
   }
   return HMILevel::HMI_BACKGROUND;
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index e6ebaf3b83..570aee180c 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -1170,7 +1170,7 @@ void PolicyHandler::OnAllowSDLFunctionalityNotification(
         continue;
       }
       policy_manager_->SetUserConsentForDevice(device_id, is_allowed);
-      uint32_t device_handle = 0;
+      connection_handler::DeviceHandle device_handle = 0;
       if (!connection_handler.GetDeviceID(device_id, &device_handle)) {
         LOG4CXX_WARN(logger_,
                      "Device handle with mac " << device_id
@@ -1204,7 +1204,7 @@ void PolicyHandler::OnAllowSDLFunctionalityNotification(
   }
 
   // Case, when specific device was changed
-  uint32_t device_handle = 0u;
+  connection_handler::DeviceHandle device_handle = 0u;
   if (device_specific) {
     policy_manager_->SetUserConsentForDevice(device_mac, is_allowed);
     if (!connection_handler.GetDeviceID(device_mac, &device_handle)) {
diff --git a/src/components/application_manager/src/state_controller_impl.cc b/src/components/application_manager/src/state_controller_impl.cc
index b456ff6abb..84081a3830 100644
--- a/src/components/application_manager/src/state_controller_impl.cc
+++ b/src/components/application_manager/src/state_controller_impl.cc
@@ -123,7 +123,7 @@ void StateControllerImpl::SetRegularState(
   HmiStatePtr prev_regular = app->RegularHmiState();
   DCHECK_OR_RETURN_VOID(prev_regular);
   HmiStatePtr hmi_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(hmi_state);
   hmi_state->set_hmi_level(hmi_level);
   hmi_state->set_audio_streaming_state(audio_state);
@@ -144,7 +144,7 @@ void StateControllerImpl::SetRegularState(
     return;
   }
   const HmiStatePtr hmi_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
 
   DCHECK_OR_RETURN_VOID(hmi_state);
   hmi_state->set_hmi_level(hmi_level);
@@ -166,7 +166,7 @@ void StateControllerImpl::SetRegularState(
     return;
   }
   HmiStatePtr hmi_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(hmi_state);
   hmi_state->set_hmi_level(hmi_level);
   hmi_state->set_audio_streaming_state(audio_state);
@@ -184,7 +184,7 @@ void StateControllerImpl::SetRegularState(
   }
   HmiStatePtr prev_state = app->RegularHmiState();
   HmiStatePtr hmi_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(hmi_state);
   hmi_state->set_hmi_level(hmi_level);
   hmi_state->set_audio_streaming_state(CalcAudioState(app, hmi_level));
@@ -206,7 +206,7 @@ void StateControllerImpl::SetRegularState(
   HmiStatePtr prev_regular = app->RegularHmiState();
   DCHECK_OR_RETURN_VOID(prev_regular);
   HmiStatePtr hmi_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(hmi_state);
   hmi_state->set_hmi_level(prev_regular->hmi_level());
   hmi_state->set_audio_streaming_state(
@@ -227,7 +227,7 @@ void StateControllerImpl::SetRegularState(
   HmiStatePtr prev_state = app->RegularHmiState();
   DCHECK_OR_RETURN_VOID(prev_state);
   HmiStatePtr hmi_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(hmi_state);
   hmi_state->set_hmi_level(prev_state->hmi_level());
   hmi_state->set_audio_streaming_state(audio_state);
@@ -325,7 +325,7 @@ HmiStatePtr StateControllerImpl::ResolveHmiState(ApplicationSharedPtr app,
                     << state->system_context());
 
   HmiStatePtr available_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN(available_state, HmiStatePtr());
   available_state->set_hmi_level(state->hmi_level());
   available_state->set_audio_streaming_state(state->audio_streaming_state());
@@ -502,7 +502,7 @@ void StateControllerImpl::SetupRegularHmiState(ApplicationSharedPtr app,
                              << ", system_context " << state->system_context());
   HmiStatePtr curr_state = app->CurrentHmiState();
   HmiStatePtr old_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(old_state);
   old_state->set_hmi_level(curr_state->hmi_level());
   old_state->set_audio_streaming_state(curr_state->audio_streaming_state());
@@ -533,7 +533,7 @@ void StateControllerImpl::SetupRegularHmiState(
   HmiStatePtr prev_state = app->RegularHmiState();
   DCHECK_OR_RETURN_VOID(prev_state);
   HmiStatePtr new_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(new_state);
   new_state->set_hmi_level(hmi_level);
   new_state->set_audio_streaming_state(audio_state);
@@ -716,7 +716,7 @@ void StateControllerImpl::OnApplicationRegistered(
   active_states_lock_.Acquire();
   StateIDList::iterator it = active_states_.begin();
   for (; it != active_states_.end(); ++it) {
-    HmiStatePtr new_state = CreateHmiState(app->app_id(), *it);
+    HmiStatePtr new_state = CreateHmiState(app, *it);
     DCHECK_OR_RETURN_VOID(new_state);
     DCHECK_OR_RETURN_VOID(new_state->state_id() != HmiState::STATE_ID_REGULAR);
     HmiStatePtr old_hmi_state = app->CurrentHmiState();
@@ -726,7 +726,7 @@ void StateControllerImpl::OnApplicationRegistered(
   active_states_lock_.Release();
 
   HmiStatePtr default_state =
-      CreateHmiState(app->app_id(), HmiState::StateID::STATE_ID_REGULAR);
+      CreateHmiState(app, HmiState::StateID::STATE_ID_REGULAR);
   DCHECK_OR_RETURN_VOID(default_state);
   default_state->set_hmi_level(default_level);
   default_state->set_audio_streaming_state(CalcAudioState(app, default_level));
@@ -896,49 +896,49 @@ bool StateControllerImpl::IsStateActive(HmiState::StateID state_id) const {
 }
 
 HmiStatePtr StateControllerImpl::CreateHmiState(
-    uint32_t app_id, HmiState::StateID state_id) const {
+    utils::SharedPtr<Application> app, HmiState::StateID state_id) const {
   using namespace utils;
   LOG4CXX_AUTO_TRACE(logger_);
   HmiStatePtr new_state;
   switch (state_id) {
     case HmiState::STATE_ID_PHONE_CALL: {
-      new_state = MakeShared<PhoneCallHmiState>(app_id, app_mngr_);
+      new_state = MakeShared<PhoneCallHmiState>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_SAFETY_MODE: {
-      new_state = MakeShared<SafetyModeHmiState>(app_id, app_mngr_);
+      new_state = MakeShared<SafetyModeHmiState>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_VR_SESSION: {
-      new_state = MakeShared<VRHmiState>(app_id, app_mngr_);
+      new_state = MakeShared<VRHmiState>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_TTS_SESSION: {
-      new_state = MakeShared<TTSHmiState>(app_id, app_mngr_);
+      new_state = MakeShared<TTSHmiState>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_NAVI_STREAMING: {
-      new_state = MakeShared<NaviStreamingHmiState>(app_id, app_mngr_);
+      new_state = MakeShared<NaviStreamingHmiState>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_REGULAR: {
-      new_state = MakeShared<HmiState>(app_id, app_mngr_);
+      new_state = MakeShared<HmiState>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_POSTPONED: {
-      new_state = MakeShared<HmiState>(app_id, app_mngr_, state_id);
+      new_state = MakeShared<HmiState>(app, app_mngr_, state_id);
       break;
     }
     case HmiState::STATE_ID_DEACTIVATE_HMI: {
-      new_state = MakeShared<DeactivateHMI>(app_id, app_mngr_);
+      new_state = MakeShared<DeactivateHMI>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_AUDIO_SOURCE: {
-      new_state = MakeShared<AudioSource>(app_id, app_mngr_);
+      new_state = MakeShared<AudioSource>(app, app_mngr_);
       break;
     }
     case HmiState::STATE_ID_EMBEDDED_NAVI: {
-      new_state = MakeShared<EmbeddedNavi>(app_id, app_mngr_);
+      new_state = MakeShared<EmbeddedNavi>(app, app_mngr_);
       break;
     }
     default: