Bug Fixes and ImprovementsSynchronizationCommit

Fix Empty perform iteration request
Fix type of name from string to enum
SendLocation implemented on HTML5 HMI
Fixed PI response on VR rejection due to high priority.
Fix Apps not responsive/not able to start app/apps remain listed on SYNC even after USB disconnect
Mobile API change and processing capabilities
Change perform interaction request conditions.
Fix SDL must always start 3sec timer before resuming the HMILevel of the app
Remove redundant StartSavePersistentDataTimer() call.
Change wrong predicate name to right.
Added stream request handling feature
Made streaming timeout in media manager configurable
Put navi app in LIMITED in case of phone call
Handling of audio state for applications
Add stop streaming timeout into ini file
Implement HMILevel resumption for job-1
Fix result code ABORTED when interrupts it by Voice recognition activation
Fix incorrect value parameter unexpectedDisconnect in BCOnAppUnregistered
Fix SDL send BC.OnAppUnregistered with "unexpectedDisconnect" set to "true" in case received from HMI OnExitAllApplications {"reason":"MASTER_RESET"}
Fix Update ini file for iAP1 support
Current working directory added to image path
Fix helpers to make it workable with more then 2 parameters
DCHECK() for ManageMobileCommand() replaced with log message because the latter returns false in some regular situations (e.g. TOO_MANY_PENDING_REQUESTS, see SDLAQ-CRS-10)
Remove connection after closing.

Signed-off-by: Justin Dickow <jjdickow@gmail.com>

1 files changed, 431 insertions, 66 deletions

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 dacac9e010..3a951cfbb6 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
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) 2014, Ford Motor Company
  * All rights reserved.
  *
@@ -37,22 +37,23 @@
 #include <vector>
 #include <map>
 #include <set>
+#include <algorithm>
+
 #include "application_manager/hmi_command_factory.h"
 #include "application_manager/application_manager.h"
 #include "application_manager/hmi_capabilities.h"
 #include "application_manager/message.h"
+#include "application_manager/message_helper.h"
 #include "application_manager/request_controller.h"
 #include "application_manager/resume_ctrl.h"
 #include "application_manager/vehicle_info_data.h"
 #include "protocol_handler/protocol_observer.h"
 #include "hmi_message_handler/hmi_message_observer.h"
 #include "hmi_message_handler/hmi_message_sender.h"
-
+#include "application_manager/policies/policy_handler_observer.h"
 #include "media_manager/media_manager_impl.h"
-
 #include "connection_handler/connection_handler_observer.h"
 #include "connection_handler/device.h"
-
 #include "formatters/CSmartFactory.hpp"
 
 #include "interfaces/HMI_API.h"
@@ -73,10 +74,9 @@
 #include "utils/threads/message_loop_thread.h"
 #include "utils/lock.h"
 #include "utils/singleton.h"
+#include "utils/data_accessor.h"
+
 
-namespace policy {
-class PolicyManager;
-}
 
 namespace NsSmartDeviceLink {
 namespace NsSmartObjects {
@@ -163,15 +163,26 @@ typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromMobile> >
 typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToMobile> > ToMobileQueue;
 typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageFromHmi> > FromHmiQueue;
 typedef threads::MessageLoopThread<utils::PrioritizedQueue<MessageToHmi> > ToHmiQueue;
+
+// AudioPassThru
+typedef struct  {
+std::vector<uint8_t> binary_data;
+int32_t              session_key;
+} AudioData;
+typedef std::queue<AudioData>                          RawAudioDataQueue;
+typedef threads::MessageLoopThread<RawAudioDataQueue>  AudioPassThruQueue;
 }
+
 typedef std::vector<std::string> RPCParams;
 
 class ApplicationManagerImpl : public ApplicationManager,
   public hmi_message_handler::HMIMessageObserver,
   public protocol_handler::ProtocolObserver,
   public connection_handler::ConnectionHandlerObserver,
+  public policy::PolicyHandlerObserver,
   public impl::FromMobileQueue::Handler, public impl::ToMobileQueue::Handler,
   public impl::FromHmiQueue::Handler, public impl::ToHmiQueue::Handler,
+  public impl::AudioPassThruQueue::Handler,
   public utils::Singleton<ApplicationManagerImpl> {
 
     friend class ResumeCtrl;
@@ -244,13 +255,21 @@ class ApplicationManagerImpl : public ApplicationManager,
      * @param vehicle_info Enum value of type of vehicle data
      * @param new value (for integer values currently) of vehicle data
      */
-    std::vector<utils::SharedPtr<Application>> IviInfoUpdated(
+    std::vector<ApplicationSharedPtr> IviInfoUpdated(
       VehicleDataType vehicle_info, int value);
 
     /////////////////////////////////////////////////////
 
     HMICapabilities& hmi_capabilities();
 
+    /**
+     * @brief ProcessQueryApp executes logic related to QUERY_APP system request.
+     *
+     * @param sm_object smart object wich is actually parsed json obtained within
+     * system request.
+     */
+    void ProcessQueryApp(const smart_objects::SmartObject& sm_object);
+
 #ifdef TIME_TESTER
     /**
      * @brief Setup observer for time metric.
@@ -278,12 +297,10 @@ class ApplicationManagerImpl : public ApplicationManager,
                                bool is_unexpected_disconnect = false);
 
     /**
-    * @brief Unregister application revoked by Policy
+    * @brief Handle sequence for unauthorized application
     * @param app_id Application id
-    * @param reason Reason of unregistering application
     */
-    void UnregisterRevokedApplication(const uint32_t& app_id,
-                                      mobile_apis::Result::eType reason);
+    void OnAppUnauthorized(const uint32_t& app_id);
 
     /*
      * @brief Sets unregister reason for closing all registered applications
@@ -303,15 +320,9 @@ class ApplicationManagerImpl : public ApplicationManager,
         mobile_api::AppInterfaceUnregisteredReason::eType reason);
 
     /*
-     * @brief Called by HMI on SUSPEND.
-     * SDL must save all persistence data(Resume, Policy)
-     */
-    void HeadUnitSuspend();
-
-    /*
      * @brief Closes all registered applications
      */
-    void UnregisterAllApplications(bool generated_by_hmi = false);
+    void UnregisterAllApplications();
 
     bool RemoveAppDataFromHMI(ApplicationSharedPtr app);
     bool LoadAppDataToHMI(ApplicationSharedPtr app);
@@ -324,7 +335,7 @@ class ApplicationManagerImpl : public ApplicationManager,
      * @param app, application, that need to be puted in FULL
      * @return seted HMI Level
      */
-    mobile_api::HMILevel::eType PutApplicationInFull(ApplicationSharedPtr app);
+    mobile_api::HMILevel::eType IsHmiLevelFullAllowed(ApplicationSharedPtr app);
 
     void ConnectToDevice(uint32_t id);
     void OnHMIStartedCooperation();
@@ -391,6 +402,20 @@ class ApplicationManagerImpl : public ApplicationManager,
      */
     void set_all_apps_allowed(const bool& allowed);
 
+
+    /**
+     * @brief Notification from PolicyHandler about PTU.
+     * Compares AppHMIType between saved in app and received from PTU. If they are different method sends:
+     * UI_ChangeRegistration with list new AppHMIType;
+     * ActivateApp with HMI level BACKGROUND;
+     * OnHMIStatus notification;
+     * for app with HMI level FULL or LIMITED.
+     * method sends:
+     * UI_ChangeRegistration with list new AppHMIType
+     * for app with HMI level BACKGROUND.
+     */
+    virtual void OnUpdateHMIAppType(std::map<std::string, std::vector<std::string> > app_hmi_types);
+
     /*
      * @brief Starts audio pass thru thread
      *
@@ -412,8 +437,17 @@ class ApplicationManagerImpl : public ApplicationManager,
      */
     void StopAudioPassThru(int32_t application_key);
 
+    /*
+     * @brief Creates AudioPassThru data chunk and inserts it
+     * to audio_pass_thru_messages_
+     *
+     * @param session_key Id of application for which
+     * audio pass thru should be sent
+     *
+     * @param binary_data AudioPassThru data chunk
+     */
     void SendAudioPassThroughNotification(uint32_t session_key,
-                                          std::vector<uint8_t> binaryData);
+                                          std::vector<uint8_t>& binary_data);
 
     std::string GetDeviceName(connection_handler::DeviceHandle handle);
 
@@ -430,42 +464,39 @@ class ApplicationManagerImpl : public ApplicationManager,
     // Put message to the queue to be sent to mobile.
     // if |final_message| parameter is set connection to mobile will be closed
     // after processing this message
-    void SendMessageToMobile(
-      const utils::SharedPtr<smart_objects::SmartObject> message,
-      bool final_message = false);
+    void SendMessageToMobile(const commands::MessageSharedPtr message,
+                             bool final_message = false);
+
     bool ManageMobileCommand(
-      const utils::SharedPtr<smart_objects::SmartObject> message);
-    void SendMessageToHMI(
-      const utils::SharedPtr<smart_objects::SmartObject> message);
-    bool ManageHMICommand(
-      const utils::SharedPtr<smart_objects::SmartObject> message);
+            const commands::MessageSharedPtr message,
+            commands::Command::CommandOrigin origin =
+            commands::Command::ORIGIN_SDL);
+    void SendMessageToHMI(const commands::MessageSharedPtr message);
+    bool ManageHMICommand(const commands::MessageSharedPtr message);
 
     /////////////////////////////////////////////////////////
-    /*
-     * @brief Overriden ProtocolObserver method
-     */
+    // Overriden ProtocolObserver method
     virtual void OnMessageReceived(
-        const ::protocol_handler::RawMessagePtr message);
-
-    /*
-     * @brief Overriden ProtocolObserver method
-     */
+        const ::protocol_handler::RawMessagePtr message) OVERRIDE;
     virtual void OnMobileMessageSent(
-        const ::protocol_handler::RawMessagePtr message);
+        const ::protocol_handler::RawMessagePtr message) OVERRIDE;
 
-    void OnMessageReceived(hmi_message_handler::MessageSharedPointer message);
-    void OnErrorSending(hmi_message_handler::MessageSharedPointer message);
+    // Overriden HMIMessageObserver method
+    void OnMessageReceived(hmi_message_handler::MessageSharedPointer message) OVERRIDE;
+    void OnErrorSending(hmi_message_handler::MessageSharedPointer message) OVERRIDE;
 
-    void OnDeviceListUpdated(const connection_handler::DeviceMap& device_list);
+    // Overriden ConnectionHandlerObserver method
+    void OnDeviceListUpdated(const connection_handler::DeviceMap& device_list) OVERRIDE;
     //TODO (EZamakhov): fix all indentations in this file
-  virtual void OnFindNewApplicationsRequest();
-    void RemoveDevice(const connection_handler::DeviceHandle& device_handle);
+    void OnFindNewApplicationsRequest() OVERRIDE;
+    void RemoveDevice(const connection_handler::DeviceHandle& device_handle) OVERRIDE;
     bool OnServiceStartedCallback(
-      const connection_handler::DeviceHandle& device_handle,
-      const int32_t& session_key, const protocol_handler::ServiceType& type);
+        const connection_handler::DeviceHandle& device_handle,
+        const int32_t& session_key, const protocol_handler::ServiceType& type) OVERRIDE;
     void OnServiceEndedCallback(const int32_t& session_key,
-                                const protocol_handler::ServiceType& type);
-
+                                const protocol_handler::ServiceType& type) OVERRIDE;
+    void OnApplicationFloodCallBack(const uint32_t& connection_key) OVERRIDE;
+    void OnMalformedMessageCallback(const uint32_t& connection_key) OVERRIDE;
     /**
      * @ Add notification to collection
      *
@@ -508,6 +539,21 @@ class ApplicationManagerImpl : public ApplicationManager,
      */
     void set_application_id(const int32_t correlation_id, const uint32_t app_id);
 
+    /**
+     * @brief AddPolicyObserver allows to subscribe needed component to events
+     * from policy.
+     *
+     * @param listener the component to subscribe.
+     */
+    void AddPolicyObserver(PolicyHandlerObserver* listener);
+
+    /**
+     * @brief RemovePolicyObserver allows to remove observer from collection.
+     *
+     * @param listener observer to remove.
+     */
+    void RemovePolicyObserver(PolicyHandlerObserver* listener);
+
     /*
      * @brief Change AudioStreamingState for all application according to
      * system audio-mixing capabilities (NOT_AUDIBLE/ATTENUATED) and
@@ -538,6 +584,36 @@ class ApplicationManagerImpl : public ApplicationManager,
     bool IsVideoStreamingAllowed(uint32_t connection_key) const;
 
     /**
+     * @brief CanAppStream allows to check whether application is permited for
+     * data streaming.
+     *
+     * In case streaming for app is disallowed the method will send EndService to mobile.
+     *
+     * @param app_id the application id which should be checked.
+     *
+     * @return true in case streaming is allowed, false otherwise.
+     */
+    bool CanAppStream(uint32_t app_id) const;
+
+    /**
+     * @brief StreamingEnded Callback called from MediaManager when it decide that
+     * streaming has been ended
+     *
+     * @param app_id the id of application that stops stream.
+     */
+    void StreamingEnded(uint32_t app_id);
+
+    /**
+     * @brief ForbidStreaming forbid the stream over the certain application.
+     *
+     * @param app_id the application's id which should stop streaming.
+     */
+    void ForbidStreaming(uint32_t app_id);
+
+    mobile_api::HMILevel::eType GetDefaultHmiLevel(
+        ApplicationSharedPtr application) const;
+
+    /**
       * Getter for resume_controller
       * @return Resume Controller
       */
@@ -642,6 +718,33 @@ class ApplicationManagerImpl : public ApplicationManager,
     void ResetPhoneCallAppList();
 
     /**
+     * @brief ChangeAppsHMILevel the function that will change application's
+     * hmi level.
+     *
+     * @param app_id id of the application whose hmi level should be changed.
+     *
+     * @param level new hmi level for certain application.
+     */
+    void ChangeAppsHMILevel(uint32_t app_id, mobile_apis::HMILevel::eType level);
+
+    /**
+     * @brief MakeAppNotAudible allows to make certain application not audible.
+     *
+     * @param app_id applicatin's id whose audible state should be changed.
+     */
+    void MakeAppNotAudible(uint32_t app_id);
+
+    /**
+     * @brief MakeAppFullScreen allows ti change application's properties
+     * in order to make it full screen.
+     *
+     * @param app_id the id of application which should be in full screen  mode.
+     *
+     * @return true if operation was success, false otherwise.
+     */
+    bool MakeAppFullScreen(uint32_t app_id);
+
+    /**
      * Function used only by HMI request/response/notification base classes
      * to change HMI app id to Mobile app id and vice versa.
      * Dot use it inside Core
@@ -667,45 +770,107 @@ class ApplicationManagerImpl : public ApplicationManager,
         mobile_apis::FunctionID::eType function_id,
         const RPCParams& rpc_params,
         CommandParametersPermissions* params_permissions = NULL);
+    /*
+     * @brief Function Should be called when Low Voltage is occured
+     */
+    void OnLowVoltage();
+
+    /*
+     * @brief Function Should be called when WakeUp occures after Low Voltage
+     */
+    void OnWakeUp();
+
+    struct ApplicationsAppIdSorter {
+      bool operator() (const ApplicationSharedPtr lhs,
+                       const ApplicationSharedPtr rhs) {
+        return lhs->app_id() < rhs->app_id();
+      }
+    };
+
+    struct ApplicationsMobileAppIdSorter {
+      bool operator() (const ApplicationSharedPtr lhs,
+                       const ApplicationSharedPtr rhs) {
+        return lhs->mobile_app_id() < rhs->mobile_app_id();
+      }
+    };
 
     // typedef for Applications list
-    typedef const std::set<ApplicationSharedPtr> TAppList;
+    typedef std::set<ApplicationSharedPtr,
+                     ApplicationsAppIdSorter> ApplictionSet;
+
+    typedef std::set<ApplicationSharedPtr,
+                     ApplicationsMobileAppIdSorter> AppsWaitRegistrationSet;
 
     // typedef for Applications list iterator
-    typedef std::set<ApplicationSharedPtr>::iterator TAppListIt;
+    typedef ApplictionSet::iterator ApplictionSetIt;
 
     // typedef for Applications list const iterator
-    typedef std::set<ApplicationSharedPtr>::const_iterator TAppListConstIt;
+    typedef ApplictionSet::const_iterator ApplictionSetConstIt;
+
 
     /**
      * Class for thread-safe access to applications list
      */
-    class ApplicationListAccessor {
+    class ApplicationListAccessor: public DataAccessor<ApplictionSet> {
      public:
 
       /**
        * @brief ApplicationListAccessor class constructor
        */
-      ApplicationListAccessor() {
-        ApplicationManagerImpl::instance()->applications_list_lock_.Acquire();
+      ApplicationListAccessor() :
+        DataAccessor<ApplictionSet>(ApplicationManagerImpl::instance()->applications_,
+                     ApplicationManagerImpl::instance()->applications_list_lock_) {
       }
 
-      /**
-       * @brief ApplicationListAccessor class destructor
-       */
-      ~ApplicationListAccessor() {
-        ApplicationManagerImpl::instance()->applications_list_lock_.Release();
-      }
+      ~ApplicationListAccessor();
 
-      // TODO(VS): Now we have return application list by value, because we have
-      // situations, when our process is killed without Stop method called.
-      // This problem must be discussed and fixed.
       /**
        * @brief thread-safe getter for applications
        * @return applications list
        */
-      TAppList applications() {
-        return ApplicationManagerImpl::instance()->application_list_;
+      const ApplictionSet& applications() const {
+        return GetData();
+      }
+
+      ApplictionSetConstIt begin() {
+        return applications().begin();
+      }
+
+      ApplictionSetConstIt end() {
+        return applications().end();
+      }
+
+      template<class UnaryPredicate>
+      ApplicationSharedPtr Find(UnaryPredicate finder) {
+        ApplicationSharedPtr result;
+        ApplictionSetConstIt it = std::find_if(begin(), end(), finder);
+        if (it != end()) {
+          result = *it;
+        }
+        return result;
+      }
+
+      template<class UnaryPredicate>
+      std::vector<ApplicationSharedPtr> FindAll(UnaryPredicate finder) {
+        std::vector<ApplicationSharedPtr> result;
+        ApplictionSetConstIt it = std::find_if(begin(), end(), finder);
+        while (it != end()) {
+          result.push_back(*it);
+          it  = std::find_if(++it, end(), finder);
+        }
+        return result;
+      }
+
+      void Erase(ApplicationSharedPtr app_to_remove) {
+        ApplicationManagerImpl::instance()->applications_.erase(app_to_remove);
+      }
+
+      void Insert(ApplicationSharedPtr app_to_insert) {
+        ApplicationManagerImpl::instance()->applications_.insert(app_to_insert);
+      }
+
+      bool Empty() {
+        return ApplicationManagerImpl::instance()->applications_.empty();
       }
 
      private:
@@ -714,9 +879,68 @@ class ApplicationManagerImpl : public ApplicationManager,
 
     friend class ApplicationListAccessor;
 
+    struct AppIdPredicate {
+      uint32_t app_id_;
+      AppIdPredicate(uint32_t app_id): app_id_(app_id) {}
+      bool operator () (const ApplicationSharedPtr app) const {
+        return app ? app_id_ == app->app_id() : false;
+      }
+    };
+
+    struct HmiAppIdPredicate {
+      uint32_t hmi_app_id_;
+      HmiAppIdPredicate(uint32_t hmi_app_id): hmi_app_id_(hmi_app_id) {}
+      bool operator () (const ApplicationSharedPtr app) const {
+        return app ? hmi_app_id_ == app->hmi_app_id() : false;
+      }
+    };
+
+    struct MobileAppIdPredicate {
+      std::string policy_app_id_;
+      MobileAppIdPredicate(const std::string& policy_app_id):
+        policy_app_id_(policy_app_id) {}
+      bool operator () (const ApplicationSharedPtr app) const {
+        return app ? policy_app_id_ == app->mobile_app_id() : false;
+      }
+    };
+
+    struct SubscribedToButtonPredicate {
+      mobile_apis::ButtonName::eType button_;
+      SubscribedToButtonPredicate(mobile_apis::ButtonName::eType button)
+        : button_(button) {}
+      bool operator () (const ApplicationSharedPtr app) const {
+        return app ? app->IsSubscribedToButton(button_) : false;
+      }
+    };
+
+    struct SubscribedToIVIPredicate {
+      int32_t vehicle_info_;
+      SubscribedToIVIPredicate(int32_t  vehicle_info)
+        : vehicle_info_(vehicle_info) {}
+      bool operator () (const ApplicationSharedPtr app) const {
+        return app ? app->IsSubscribedToIVI(vehicle_info_) : false;
+      }
+    };
+
   private:
     ApplicationManagerImpl();
 
+    /**
+     * @brief Method transforms string to AppHMIType
+     * @param str contains string AppHMIType
+     * @return enum AppHMIType
+     */
+    mobile_apis::AppHMIType::eType StringToAppHMIType(std::string str);
+
+    /**
+     * @brief Method compares arrays of app HMI type
+     * @param from_policy contains app HMI type from policy
+     * @param from_application contains app HMI type from application
+     * @return return TRUE if arrays of appHMIType equal, otherwise return FALSE
+     */
+    bool CompareAppHMIType (const smart_objects::SmartObject& from_policy,
+                            const smart_objects::SmartObject& from_application);
+
     hmi_apis::HMI_API& hmi_so_factory();
     mobile_apis::MOBILE_API& mobile_so_factory();
 
@@ -747,26 +971,154 @@ class ApplicationManagerImpl : public ApplicationManager,
     // CALLED ON messages_to_hmi_ thread!
     virtual void Handle(const impl::MessageToHmi message) OVERRIDE;
 
-    void SendUpdateAppList(const std::list<uint32_t>& applications_ids);
+    // CALLED ON audio_pass_thru_messages_ thread!
+    virtual void Handle(const impl::AudioData message) OVERRIDE;
+
+    void SendUpdateAppList();
+
+    template<typename ApplicationList>
+    void PrepareApplicationListSO(ApplicationList app_list,
+                                  smart_objects::SmartObject& applications) {
+      CREATE_LOGGERPTR_LOCAL(logger_, "ApplicatinManagerImpl");
+
+      uint32_t app_count = 0;
+      typename ApplicationList::const_iterator it;
+      for (it = app_list.begin(); it != app_list.end(); ++it) {
+        if (!it->valid()) {
+          LOG4CXX_ERROR(logger_, "Application not found ");
+          continue;
+        }
+
+        smart_objects::SmartObject hmi_application(smart_objects::SmartType_Map);;
+        if (MessageHelper::CreateHMIApplicationStruct(*it, hmi_application)) {
+          applications[app_count++] = hmi_application;
+        } else {
+          LOG4CXX_DEBUG(logger_, "Can't CreateHMIApplicationStruct ");
+        }
+      }
+
+      if (0 == app_count) {
+        LOG4CXX_WARN(logger_, "Empty applications list");
+      }
+    }
+
     void OnApplicationListUpdateTimer();
 
+    /**
+     * @brief CreateApplications creates aplpication adds it to application list
+     * and prepare data for sending AppIcon request.
+     *
+     * @param obj_array applications array.
+     *
+     * @param app_icon_dir application icons directory
+     *
+     * @param apps_with_icon container which store application and it's icon path.
+     */
+    void CreateApplications(smart_objects::SmartArray& obj_array);
+
     /*
      * @brief Function is called on IGN_OFF, Master_reset or Factory_defaults
      * to notify HMI that SDL is shutting down.
      */
     void SendOnSDLClose();
 
+    /*
+     * @brief returns true if low voltage state is active
+     */
+    bool IsLowVoltage();
+
   private:
 
+    /**
+     * @brief OnHMILevelChanged the callback that allows SDL to react when
+     * application's HMILeval has been changed.
+     *
+     * @param app_id application identifier for which HMILevel has been chaned.
+     *
+     * @param from previous HMILevel.
+     * @param to current HMILevel.
+     */
+    void OnHMILevelChanged(uint32_t app_id,
+                           mobile_apis::HMILevel::eType from,
+                           mobile_apis::HMILevel::eType to);
+
+    /**
+     * @brief EndNaviServices either send EndService to mobile or proceed
+     * unregister application procedure.
+     */
+    void EndNaviServices();
+
+    /**
+     * @brief CloseNaviApp allows to unregister application in case the EndServiceEndedAck
+     * didn't come for at least one of services(audio or video).
+     */
+    void CloseNaviApp();
+
+    /**
+     * @brief AckReceived allows to distinguish if ack for appropriate service
+     * has been received (means EndServiceAck).
+     *
+     * @param type service type.
+     *
+     * @return in case EndService has been sent and appropriate ack has been
+     * received it returns true. In case no EndService for appropriate serevice type
+     * has been sent and no ack has been received it returns true as well.
+     * Otherwise it will return false.
+     *
+     */
+    bool AckReceived(protocol_handler::ServiceType type);
+
+    /**
+     * @brief NaviAppChangeLevel the callback which reacts on case when applications
+     * hmi level has been changed.
+     */
+    void NaviAppChangeLevel(mobile_apis::HMILevel::eType new_level);
+
+    /**
+     * @brief ChangeStreamStatus allows to process streaming state.
+     *
+     * @param app_id id of application whose stream state has been changed.
+     *
+     * @param can_stream streaming state if true - streaming active, if false
+     * streaming is not active.
+     */
+    void ChangeStreamStatus(uint32_t app_id, bool can_stream);
+
+    /**
+     * @brief ProcessNaviService allows to start navi service
+     *
+     * @param type service type.
+     *
+     * @param connection_key the application id.
+     */
+    bool ProcessNaviService(protocol_handler::ServiceType type, uint32_t connection_key);
+
+    /**
+     * @brief NaviAppStreamStatus allows to handle case when navi streaming state
+     * has ben changed from streaming to non streaming and vise versa.
+     *
+     * @param stream_active the stream's state - is it streams or not.
+     */
+    void NaviAppStreamStatus(bool stream_active);
+
+
+    /**
+     * @brief Function returns supported SDL Protocol Version
+     * @return protocol version depends on parameters from smartDeviceLink.ini.
+     */
+    ProtocolVersion SupportedSDLVersion() const;
+
     // members
 
     /**
      * @brief List of applications
      */
-    std::set<ApplicationSharedPtr> application_list_;
+    ApplictionSet applications_;
+    AppsWaitRegistrationSet apps_to_register_;
 
     // Lock for applications list
     mutable sync_primitives::Lock applications_list_lock_;
+    mutable sync_primitives::Lock apps_to_register_list_lock_;
 
     /**
      * @brief Map of correlation id  and associated application id.
@@ -831,6 +1183,8 @@ class ApplicationManagerImpl : public ApplicationManager,
     impl::FromHmiQueue messages_from_hmi_;
     // Thread that pumps messages being passed to HMI.
     impl::ToHmiQueue messages_to_hmi_;
+    // Thread that pumps messages audio pass thru to mobile.
+    impl::AudioPassThruQueue audio_pass_thru_messages_;
 
 
     HMICapabilities                         hmi_capabilities_;
@@ -844,6 +1198,16 @@ class ApplicationManagerImpl : public ApplicationManager,
      */
     ResumeCtrl resume_ctrl_;
 
+    // The map contains service type as a key and pair as a value.
+    // The pair meaning is: first item shows if EndService has been sent and
+    // the second one shows if appropriate ACK has been received.
+    std::map<protocol_handler::ServiceType, std::pair<bool, bool> > service_status_;
+
+    timer::TimerThread<ApplicationManagerImpl> end_services_timer;
+    uint32_t wait_end_service_timeout_;
+    uint32_t navi_app_to_stop_;
+
+
 #ifdef TIME_TESTER
     AMMetricObserver* metric_observer_;
 #endif  // TIME_TESTER
@@ -860,6 +1224,7 @@ class ApplicationManagerImpl : public ApplicationManager,
 
     timer::TimerThread<ApplicationManagerImpl>  tts_global_properties_timer_;
 
+    bool is_low_voltage_;
     DISALLOW_COPY_AND_ASSIGN(ApplicationManagerImpl);
 
     FRIEND_BASE_SINGLETON_CLASS(ApplicationManagerImpl);