Add implementation for video streaming parameters

24 files changed, 869 insertions, 160 deletions

diff --git a/src/components/application_manager/CMakeLists.txt b/src/components/application_manager/CMakeLists.txt
index a5fcd469ef..0d532c9a5c 100644
--- a/src/components/application_manager/CMakeLists.txt
+++ b/src/components/application_manager/CMakeLists.txt
@@ -57,6 +57,7 @@ include_directories (
   ${ENCRYPTION_INCLUDE_DIRECTORY}
   ${MESSAGE_BROKER_INCLUDE_DIRECTORY}
   ${LOG4CXX_INCLUDE_DIRECTORY}
+  ${BSON_INCLUDE_DIRECTORY}
 )
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
@@ -399,6 +400,8 @@ set(LIBRARIES
   formatters
   dbms
   Utils
+  bson -L${BSON_LIBS_DIRECTORY}
+  emhashmap -L${EMHASHMAP_LIBS_DIRECTORY}
 )
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
@@ -437,6 +440,7 @@ if(ENABLE_LOG)
   list(APPEND LIBRARIES log4cxx -L${LOG4CXX_LIBS_DIRECTORY})
 endif()
 
+add_dependencies("ApplicationManager" libbson)
 target_link_libraries("ApplicationManager" ${LIBRARIES})
 
 if(BUILD_TESTS)
diff --git a/src/components/application_manager/include/application_manager/application.h b/src/components/application_manager/include/application_manager/application.h
index 9543193ff9..4dfb8dbf7a 100644
--- a/src/components/application_manager/include/application_manager/application.h
+++ b/src/components/application_manager/include/application_manager/application.h
@@ -37,6 +37,7 @@
 #include <map>
 #include <set>
 #include <list>
+#include <vector>
 #include "utils/shared_ptr.h"
 #include "utils/data_accessor.h"
 #include "interfaces/MOBILE_API.h"
@@ -441,6 +442,25 @@ class Application : public virtual InitialApplicationData,
   virtual void set_audio_streaming_allowed(bool state) = 0;
 
   /**
+   * @brief Sends SetVideoConfig request to HMI to configure streaming
+   * @param service_type Type of streaming service, should be kMobileNav
+   * @param params parameters of video streaming in key-value format
+   * @return true if SetVideoConfig is sent, false otherwise
+   */
+  virtual bool SetVideoConfig(protocol_handler::ServiceType service_type,
+                              const smart_objects::SmartObject& params) = 0;
+
+  /**
+   * @brief Callback when SetVideoConfig response is received
+   * @param result true if HMI accepts video streaming parameters,
+   *        false otherwise
+   * @param rejected_params list of rejected parameters' names. Only
+   *        valid when result is false
+   */
+  virtual void OnNaviSetVideoConfigDone(
+      bool result, std::vector<std::string>& rejected_params) = 0;
+
+  /**
    * @brief Starts streaming service for application
    * @param service_type Type of streaming service
    */
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 9ef2fb936c..f5db389c7f 100644
--- a/src/components/application_manager/include/application_manager/application_impl.h
+++ b/src/components/application_manager/include/application_manager/application_impl.h
@@ -110,6 +110,10 @@ class ApplicationImpl : public virtual InitialApplicationDataImpl,
   bool audio_streaming_allowed() const;
   void set_audio_streaming_allowed(bool state);
 
+  bool SetVideoConfig(protocol_handler::ServiceType service_type,
+                      const smart_objects::SmartObject& params);
+  void OnNaviSetVideoConfigDone(bool result,
+                                std::vector<std::string>& rejected_params);
   void StartStreaming(protocol_handler::ServiceType service_type);
   void StopStreamingForce(protocol_handler::ServiceType service_type);
   void StopStreaming(protocol_handler::ServiceType service_type);
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 313219116d..47a77a1f97 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
@@ -93,6 +93,8 @@
 #include "utils/timer.h"
 #include "smart_objects/smart_object.h"
 
+struct BsonObject;
+
 namespace threads {
 class Thread;
 }
@@ -792,10 +794,11 @@ class ApplicationManagerImpl
   void OnFindNewApplicationsRequest() OVERRIDE;
   void RemoveDevice(
       const connection_handler::DeviceHandle& device_handle) OVERRIDE;
-  bool OnServiceStartedCallback(
+  void OnServiceStartedCallback(
       const connection_handler::DeviceHandle& device_handle,
       const int32_t& session_key,
-      const protocol_handler::ServiceType& type) OVERRIDE;
+      const protocol_handler::ServiceType& type,
+      const BsonObject* params) OVERRIDE;
   void OnServiceEndedCallback(
       const int32_t& session_key,
       const protocol_handler::ServiceType& type,
@@ -886,6 +889,19 @@ class ApplicationManagerImpl
   void ForbidStreaming(uint32_t app_id) OVERRIDE;
 
   /**
+   * @brief Called when application completes streaming configuration
+   * @param app_id Streaming application id
+   * @param service_type Streaming service type
+   * @param result true if configuration is successful, false otherwise
+   * @param rejected_params list of rejected parameters' name. Valid
+   *                        only when result is false.
+   */
+  void OnStreamingConfigured(uint32_t app_id,
+                             protocol_handler::ServiceType service_type,
+                             bool result,
+                             std::vector<std::string>& rejected_params);
+
+  /**
    * @brief Callback calls when application starts/stops data streaming
    * @param app_id Streaming application id
    * @param service_type Streaming service type
@@ -1325,10 +1341,13 @@ class ApplicationManagerImpl
    * @brief Starts specified navi service for application
    * @param app_id Application to proceed
    * @param service_type Type of service to start
-   * @return True on success, false on fail
+   * @param params configuration parameters specified by mobile
+   * @return True if service is immediately started or configuration
+   * parameters are sent to HMI, false on other cases
    */
   bool StartNaviService(uint32_t app_id,
-                        protocol_handler::ServiceType service_type);
+                        protocol_handler::ServiceType service_type,
+                        const BsonObject* params);
 
   /**
    * @brief Stops specified navi service for application
@@ -1399,6 +1418,24 @@ class ApplicationManagerImpl
 
   void ClearTTSGlobalPropertiesList();
 
+  /**
+   * @brief Converts BSON object containing video parameters to
+   * smart object's map object
+   * @param output the smart object to add video parameters
+   * @param input BSON object to read parameters from
+   */
+  static void ConvertVideoParamsToSO(smart_objects::SmartObject& output,
+                                     const BsonObject* input);
+
+  /**
+   * @brief Converts rejected parameters' names acquired from HMI to
+   * SDL protocol's parameter names
+   * @param list of rejected parameters' names
+   * @return converted parameters' names
+   */
+  static std::vector<std::string> ConvertRejectedParamList(
+      const std::vector<std::string>& input);
+
  private:
   const ApplicationManagerSettings& settings_;
   /**
diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc
index 7e9215b0be..7d9025050a 100644
--- a/src/components/application_manager/src/application_impl.cc
+++ b/src/components/application_manager/src/application_impl.cc
@@ -416,6 +416,33 @@ bool ApplicationImpl::audio_streaming_allowed() const {
   return audio_streaming_allowed_;
 }
 
+bool ApplicationImpl::SetVideoConfig(protocol_handler::ServiceType service_type,
+                                     const smart_objects::SmartObject& params) {
+  using namespace protocol_handler;
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  if (ServiceType::kMobileNav == service_type) {
+    // See StartStreaming(). We issue SetVideoConfig and StartStream
+    // only when streaming is not approved yet
+    if (!video_streaming_approved()) {
+      LOG4CXX_TRACE(logger_, "Video streaming not approved");
+      MessageHelper::SendNaviSetVideoConfig(
+          app_id(), application_manager_, params);
+      return true;
+    }
+  }
+  return false;
+}
+
+void ApplicationImpl::OnNaviSetVideoConfigDone(
+    bool result, std::vector<std::string>& rejected_params) {
+  using namespace protocol_handler;
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  application_manager_.OnStreamingConfigured(
+      app_id(), ServiceType::kMobileNav, result, rejected_params);
+}
+
 void ApplicationImpl::StartStreaming(
     protocol_handler::ServiceType service_type) {
   using namespace protocol_handler;
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 85c3469324..a76edc2747 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -36,6 +36,7 @@
 #include <string>
 #include <fstream>
 #include <utility>
+#include <bson_object.h>
 
 #include "application_manager/application_manager_impl.h"
 #include "application_manager/mobile_command_factory.h"
@@ -1138,7 +1139,9 @@ void ApplicationManagerImpl::ReplaceHMIByMobileAppId(
 }
 
 bool ApplicationManagerImpl::StartNaviService(
-    uint32_t app_id, protocol_handler::ServiceType service_type) {
+    uint32_t app_id,
+    protocol_handler::ServiceType service_type,
+    const BsonObject* params) {
   using namespace protocol_handler;
   LOG4CXX_AUTO_TRACE(logger_);
 
@@ -1155,6 +1158,56 @@ bool ApplicationManagerImpl::StartNaviService(
       }
       it = res.first;
     }
+
+    if (service_type == ServiceType::kMobileNav) {
+      smart_objects::SmartObject converted_params(smart_objects::SmartType_Map);
+      ConvertVideoParamsToSO(converted_params, params);
+
+      if (!converted_params.empty()) {
+        LOG4CXX_INFO(logger_, "Sending video configuration params");
+#ifdef DEBUG
+        MessageHelper::PrintSmartObject(converted_params);
+#endif
+        bool request_sent =
+            application(app_id)->SetVideoConfig(service_type, converted_params);
+        if (request_sent) {
+          return true;
+        }
+      }
+    }
+    // no configuration is needed, or SetVideoConfig is not sent
+    std::vector<std::string> empty;
+    OnStreamingConfigured(app_id, service_type, true, empty);
+    return true;
+
+  } else {
+    LOG4CXX_WARN(logger_, "Refused navi service by HMI level");
+  }
+  return false;
+}
+
+void ApplicationManagerImpl::OnStreamingConfigured(
+    uint32_t app_id,
+    protocol_handler::ServiceType service_type,
+    bool result,
+    std::vector<std::string>& rejected_params) {
+  using namespace protocol_handler;
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  std::vector<std::string> empty;
+
+  LOG4CXX_INFO(logger_,
+               "OnStreamingConfigured called for service "
+                   << service_type << ", result=" << result);
+
+  if (result) {
+    NaviServiceStatusMap::iterator it = navi_service_status_.find(app_id);
+    if (navi_service_status_.end() == it) {
+      LOG4CXX_WARN(logger_, "Application not found in navi status map");
+      connection_handler().NotifyServiceStartedResult(false, empty);
+      return;
+    }
+
     // Fill NaviServices map. Set true to first value of pair if
     // we've started video service or to second value if we've
     // started audio service
@@ -1162,11 +1215,12 @@ bool ApplicationManagerImpl::StartNaviService(
                                             : it->second.second = true;
 
     application(app_id)->StartStreaming(service_type);
-    return true;
+    connection_handler().NotifyServiceStartedResult(true, empty);
   } else {
-    LOG4CXX_WARN(logger_, "Refused navi service by HMI level");
+    std::vector<std::string> converted_params =
+        ConvertRejectedParamList(rejected_params);
+    connection_handler().NotifyServiceStartedResult(false, converted_params);
   }
-  return false;
 }
 
 void ApplicationManagerImpl::StopNaviService(
@@ -1194,40 +1248,47 @@ void ApplicationManagerImpl::StopNaviService(
   app->StopStreaming(service_type);
 }
 
-bool ApplicationManagerImpl::OnServiceStartedCallback(
+void ApplicationManagerImpl::OnServiceStartedCallback(
     const connection_handler::DeviceHandle& device_handle,
     const int32_t& session_key,
-    const protocol_handler::ServiceType& type) {
+    const protocol_handler::ServiceType& type,
+    const BsonObject* params) {
   using namespace helpers;
   using namespace protocol_handler;
   LOG4CXX_AUTO_TRACE(logger_);
   LOG4CXX_DEBUG(logger_,
                 "ServiceType = " << type << ". Session = " << std::hex
                                  << session_key);
+  std::vector<std::string> empty;
 
   if (type == kRpc) {
     LOG4CXX_DEBUG(logger_, "RPC service is about to be started.");
-    return true;
+    connection_handler().NotifyServiceStartedResult(true, empty);
+    return;
   }
   ApplicationSharedPtr app = application(session_key);
   if (!app) {
     LOG4CXX_WARN(logger_,
                  "The application with id:" << session_key
                                             << " doesn't exists.");
-    return false;
+    connection_handler().NotifyServiceStartedResult(false, empty);
+    return;
   }
 
   if (Compare<ServiceType, EQ, ONE>(
           type, ServiceType::kMobileNav, ServiceType::kAudio)) {
     if (app->is_navi() || app->mobile_projection_enabled()) {
-      return StartNaviService(session_key, type);
+      if (!StartNaviService(session_key, type, params)) {
+        connection_handler().NotifyServiceStartedResult(false, empty);
+      }
+      return;
     } else {
       LOG4CXX_WARN(logger_, "Refuse not navi/projection application");
     }
   } else {
     LOG4CXX_WARN(logger_, "Refuse unknown service");
   }
-  return false;
+  connection_handler().NotifyServiceStartedResult(false, empty);
 }
 
 void ApplicationManagerImpl::OnServiceEndedCallback(
@@ -3606,4 +3667,90 @@ const std::set<int32_t> ApplicationManagerImpl::GetAppsSubscribedForWayPoints()
   return subscribed_way_points_apps_list_;
 }
 
+static hmi_apis::Common_VideoStreamingProtocol::eType ConvertVideoProtocol(
+    const char* str) {
+  if (strcmp(str, "RAW") == 0) {
+    return hmi_apis::Common_VideoStreamingProtocol::RAW;
+  } else if (strcmp(str, "RTP") == 0) {
+    return hmi_apis::Common_VideoStreamingProtocol::RTP;
+  } else if (strcmp(str, "RTSP") == 0) {
+    return hmi_apis::Common_VideoStreamingProtocol::RTSP;
+  } else if (strcmp(str, "RTMP") == 0) {
+    return hmi_apis::Common_VideoStreamingProtocol::RTMP;
+  } else if (strcmp(str, "WEBM") == 0) {
+    return hmi_apis::Common_VideoStreamingProtocol::WEBM;
+  }
+  return hmi_apis::Common_VideoStreamingProtocol::INVALID_ENUM;
+}
+
+static hmi_apis::Common_VideoStreamingCodec::eType ConvertVideoCodec(
+    const char* str) {
+  if (strcmp(str, "H264") == 0) {
+    return hmi_apis::Common_VideoStreamingCodec::H264;
+  } else if (strcmp(str, "H265") == 0) {
+    return hmi_apis::Common_VideoStreamingCodec::H265;
+  } else if (strcmp(str, "Theora") == 0) {
+    return hmi_apis::Common_VideoStreamingCodec::Theora;
+  } else if (strcmp(str, "VP8") == 0) {
+    return hmi_apis::Common_VideoStreamingCodec::VP8;
+  } else if (strcmp(str, "VP9") == 0) {
+    return hmi_apis::Common_VideoStreamingCodec::VP9;
+  }
+  return hmi_apis::Common_VideoStreamingCodec::INVALID_ENUM;
+}
+
+// static
+void ApplicationManagerImpl::ConvertVideoParamsToSO(
+    smart_objects::SmartObject& output, const BsonObject* input) {
+  if (input == NULL) {
+    return;
+  }
+  BsonObject* obj = const_cast<BsonObject*>(input);
+
+  const char* protocol = bson_object_get_string(obj, "videoProtocol");
+  if (protocol != NULL) {
+    hmi_apis::Common_VideoStreamingProtocol::eType protocol_enum =
+        ConvertVideoProtocol(protocol);
+    if (protocol_enum !=
+        hmi_apis::Common_VideoStreamingProtocol::INVALID_ENUM) {
+      output["protocol"] = protocol_enum;
+    }
+  }
+  const char* codec = bson_object_get_string(obj, "videoCodec");
+  if (codec != NULL) {
+    hmi_apis::Common_VideoStreamingCodec::eType codec_enum =
+        ConvertVideoCodec(codec);
+    if (codec_enum != hmi_apis::Common_VideoStreamingCodec::INVALID_ENUM) {
+      output["codec"] = codec_enum;
+    }
+  }
+  BsonElement* element = bson_object_get(obj, "desiredHeight");
+  if (element != NULL && element->type == TYPE_INT32) {
+    output["height"] = bson_object_get_int32(obj, "desiredHeight");
+  }
+  element = bson_object_get(obj, "desiredWidth");
+  if (element != NULL && element->type == TYPE_INT32) {
+    output["width"] = bson_object_get_int32(obj, "desiredWidth");
+  }
+}
+
+// static
+std::vector<std::string> ApplicationManagerImpl::ConvertRejectedParamList(
+    const std::vector<std::string>& input) {
+  std::vector<std::string> output;
+  for (unsigned int i = 0; i < input.size(); i++) {
+    if (input[i] == "protocol") {
+      output.push_back("videoProtocol");
+    } else if (input[i] == "codec") {
+      output.push_back("videoCodec");
+    } else if (input[i] == "height") {
+      output.push_back("desiredHeight");
+    } else if (input[i] == "width") {
+      output.push_back("desiredWidth");
+    }
+    // ignore unknown parameters
+  }
+  return output;
+}
+
 }  // namespace application_manager
diff --git a/src/components/application_manager/src/commands/hmi/navi_set_video_config_request.cc b/src/components/application_manager/src/commands/hmi/navi_set_video_config_request.cc
index 3a832e0255..8a51133b36 100644
--- a/src/components/application_manager/src/commands/hmi/navi_set_video_config_request.cc
+++ b/src/components/application_manager/src/commands/hmi/navi_set_video_config_request.cc
@@ -110,7 +110,7 @@ void NaviSetVideoConfigRequest::on_event(const event_engine::Event& event) {
           }
         }
       }
-//      app->OnNaviSetVideoConfigDone(result, rejected_params);
+      app->OnNaviSetVideoConfigDone(result, rejected_params);
       break;
     }
     default:
@@ -129,8 +129,8 @@ void NaviSetVideoConfigRequest::onTimeOut() {
     return;
   }
 
-//  std::vector<std::string> empty;
-//  app->OnNaviSetVideoConfigDone(false, empty);
+  std::vector<std::string> empty;
+  app->OnNaviSetVideoConfigDone(false, empty);
 
   application_manager_.TerminateRequest(
       connection_key(), correlation_id(), function_id());
diff --git a/src/components/application_manager/test/include/application_manager/mock_application.h b/src/components/application_manager/test/include/application_manager/mock_application.h
index ae9b05bb92..53c4be1c77 100644
--- a/src/components/application_manager/test/include/application_manager/mock_application.h
+++ b/src/components/application_manager/test/include/application_manager/mock_application.h
@@ -70,6 +70,11 @@ class MockApplication : public ::application_manager::Application {
   MOCK_CONST_METHOD0(audio_streaming_allowed, bool());
   MOCK_METHOD1(set_audio_streaming_allowed, void(bool state));
   MOCK_CONST_METHOD0(is_audio, bool());
+  MOCK_METHOD2(SetVideoConfig,
+               bool(protocol_handler::ServiceType service_type,
+                    const smart_objects::SmartObject& params));
+  MOCK_METHOD2(OnNaviSetVideoConfigDone,
+               void(bool result, std::vector<std::string>& rejected_params));
   MOCK_METHOD1(StartStreaming,
                void(protocol_handler::ServiceType service_type));
   MOCK_METHOD1(StopStreaming, void(protocol_handler::ServiceType service_type));
diff --git a/src/components/connection_handler/include/connection_handler/connection_handler_impl.h b/src/components/connection_handler/include/connection_handler/connection_handler_impl.h
index a6651a6466..32a4086bc4 100644
--- a/src/components/connection_handler/include/connection_handler/connection_handler_impl.h
+++ b/src/components/connection_handler/include/connection_handler/connection_handler_impl.h
@@ -49,6 +49,7 @@
 
 #include "utils/logger.h"
 #include "utils/macro.h"
+#include "utils/message_queue.h"
 #include "utils/lock.h"
 #include "utils/stl_utils.h"
 #include "utils/rwlock.h"
@@ -174,20 +175,21 @@ class ConnectionHandlerImpl
   /**
    * \brief Callback function used by ProtocolHandler
    * when Mobile Application initiates start of new session.
-   * \param connection_handle Connection identifier within which session has to
-   * be started.
-   * \param session_id Identifier of the session to be started
+   * Result must be notified through NotifySessionStartedResult().
+   * \param connection_handle Connection identifier within which session
+   * has to be started.
+   * \param sessionId Identifier of the session to be start
    * \param service_type Type of service
+   * \param protocol_version Version of protocol
    * \param is_protected would be service protected
-   * \param hash_id pointer for session hash identifier
-   * \return uint32_t Id (number) of new session if successful, otherwise 0.
+   * \param params configuration parameters specified by mobile
    */
-  virtual uint32_t OnSessionStartedCallback(
+  virtual void OnSessionStartedCallback(
       const transport_manager::ConnectionUID connection_handle,
       const uint8_t session_id,
       const protocol_handler::ServiceType& service_type,
       const bool is_protected,
-      uint32_t* hash_id);
+      const BsonObject* params);
 
   // DEPRECATED
   uint32_t OnSessionEndedCallback(
@@ -441,8 +443,68 @@ class ConnectionHandlerImpl
   const protocol_handler::SessionObserver& get_session_observer();
   DevicesDiscoveryStarter& get_device_discovery_starter();
 
+  /**
+   * \brief Invoked when observer's OnServiceStartedCallback is completed
+   * \param result true if observer accepts starting service, false otherwise
+   * \param rejected_params list of rejected parameters' name. Only valid when
+   * result is false. Note that even if result is false, this may be empty.
+   *
+   * \note This is invoked only once but can be invoked by multiple threads.
+   * Also it can be invoked before OnServiceStartedCallback() returns.
+   **/
+  virtual void NotifyServiceStartedResult(
+      bool result, std::vector<std::string>& rejected_params);
+
  private:
   /**
+   * \brief Struct to keep variables between OnSessionStartedCallback() and
+   * NotifyServiceStartedResult()
+   **/
+  struct ServiceStartedContext {
+    transport_manager::ConnectionUID connection_handle_;
+    uint8_t session_id_;
+    uint32_t new_session_id_;
+    protocol_handler::ServiceType service_type_;
+    uint32_t hash_id_;
+    bool is_protected_;
+
+    /**
+     * \brief Constructor
+     */
+    ServiceStartedContext()
+        : connection_handle_(0)
+        , session_id_(0)
+        , new_session_id_(0)
+        , service_type_(protocol_handler::kInvalidServiceType)
+        , hash_id_(0)
+        , is_protected_(0) {}
+
+    /**
+     * \brief Constructor
+     * \param connection_handle Connection identifier within which session is
+     * started.
+     * \param session_id Session ID specified to OnSessionStartedCallback()
+     * \param new_session_id Session ID generated
+     * \param service_type Type of service
+     * \param hash_id Hash ID generated from connection_handle and
+     * new_session_id
+     * \param is_protected Whether service will be protected
+     **/
+    ServiceStartedContext(transport_manager::ConnectionUID connection_handle,
+                          uint8_t session_id,
+                          uint32_t new_session_id,
+                          protocol_handler::ServiceType service_type,
+                          uint32_t hash_id,
+                          bool is_protected)
+        : connection_handle_(connection_handle)
+        , session_id_(session_id)
+        , new_session_id_(new_session_id)
+        , service_type_(service_type)
+        , hash_id_(hash_id)
+        , is_protected_(is_protected) {}
+  };
+
+  /**
    * \brief Disconnect application.
    *
    * \param device_handle DeviceHandle of disconnected device.
@@ -452,6 +514,13 @@ class ConnectionHandlerImpl
 
   void OnConnectionEnded(const transport_manager::ConnectionUID connection_id);
 
+  /**
+   * \brief Convenient method to call NotifySessionStartedResult() with
+   * negative result.
+   * \param is_protected whether the service would be protected
+   **/
+  void NotifySessionStartedFailure(bool is_protected);
+
   const ConnectionHandlerSettings& settings_;
   /**
    * \brief Pointer to observer
@@ -486,6 +555,9 @@ class ConnectionHandlerImpl
    */
   utils::StlMapDeleter<ConnectionList> connection_list_deleter_;
 
+  // we need thread-safe queue
+  utils::MessageQueue<ServiceStartedContext> start_service_context_queue_;
+
 #ifdef BUILD_TESTS
   // Methods for test usage
  public:
diff --git a/src/components/connection_handler/src/connection_handler_impl.cc b/src/components/connection_handler/src/connection_handler_impl.cc
index 125a6cd769..735140e24f 100644
--- a/src/components/connection_handler/src/connection_handler_impl.cc
+++ b/src/components/connection_handler/src/connection_handler_impl.cc
@@ -69,7 +69,8 @@ ConnectionHandlerImpl::ConnectionHandlerImpl(
     , protocol_handler_(NULL)
     , connection_list_lock_()
     , connection_handler_observer_lock_()
-    , connection_list_deleter_(&connection_list_) {}
+    , connection_list_deleter_(&connection_list_)
+    , start_service_context_queue_() {}
 
 ConnectionHandlerImpl::~ConnectionHandlerImpl() {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -279,40 +280,42 @@ bool AllowProtection(const ConnectionHandlerSettings& settings,
 }
 #endif  // ENABLE_SECURITY
 
-uint32_t ConnectionHandlerImpl::OnSessionStartedCallback(
+void ConnectionHandlerImpl::OnSessionStartedCallback(
     const transport_manager::ConnectionUID connection_handle,
     const uint8_t session_id,
     const protocol_handler::ServiceType& service_type,
     const bool is_protected,
-    uint32_t* hash_id) {
+    const BsonObject* params) {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  if (hash_id) {
-    *hash_id = protocol_handler::HASH_ID_WRONG;
-  }
+  uint32_t new_session_id = 0;
+  uint32_t hash_id = protocol_handler::HASH_ID_WRONG;
+
 #ifdef ENABLE_SECURITY
   if (!AllowProtection(get_settings(), service_type, is_protected)) {
-    return 0;
+    std::vector<std::string> empty;
+    protocol_handler_->NotifySessionStartedResult(
+        new_session_id, hash_id, is_protected, empty);
+    return;
   }
 #endif  // ENABLE_SECURITY
   sync_primitives::AutoReadLock lock(connection_list_lock_);
   ConnectionList::iterator it = connection_list_.find(connection_handle);
   if (connection_list_.end() == it) {
     LOG4CXX_ERROR(logger_, "Unknown connection!");
-    return 0;
+    NotifySessionStartedFailure(is_protected);
+    return;
   }
-  uint32_t new_session_id = 0;
 
   Connection* connection = it->second;
   if ((0 == session_id) && (protocol_handler::kRpc == service_type)) {
     new_session_id = connection->AddNewSession();
     if (0 == new_session_id) {
       LOG4CXX_ERROR(logger_, "Couldn't start new session!");
-      return 0;
-    }
-    if (hash_id) {
-      *hash_id = KeyFromPair(connection_handle, new_session_id);
+      NotifySessionStartedFailure(is_protected);
+      return;
     }
+    hash_id = KeyFromPair(connection_handle, new_session_id);
   } else {  // Could be create new service or protected exists one
     if (!connection->AddNewService(session_id, service_type, is_protected)) {
       LOG4CXX_ERROR(logger_,
@@ -322,30 +325,87 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback(
 #endif  // ENABLE_SECURITY
                         << " service " << static_cast<int>(service_type)
                         << " for session " << static_cast<int>(session_id));
-      return 0;
+      NotifySessionStartedFailure(is_protected);
+      return;
     }
     new_session_id = session_id;
-    if (hash_id) {
-      *hash_id = protocol_handler::HASH_ID_NOT_SUPPORTED;
-    }
+    hash_id = protocol_handler::HASH_ID_NOT_SUPPORTED;
   }
   sync_primitives::AutoReadLock read_lock(connection_handler_observer_lock_);
   if (connection_handler_observer_) {
     const uint32_t session_key = KeyFromPair(connection_handle, new_session_id);
-    const bool success = connection_handler_observer_->OnServiceStartedCallback(
-        connection->connection_device_handle(), session_key, service_type);
-    if (!success) {
-      LOG4CXX_WARN(logger_,
-                   "Service starting forbidden by connection_handler_observer");
-      if (protocol_handler::kRpc == service_type) {
-        connection->RemoveSession(new_session_id);
-      } else {
-        connection->RemoveService(session_id, service_type);
-      }
-      return 0;
+
+    ServiceStartedContext context(connection_handle,
+                                  session_id,
+                                  new_session_id,
+                                  service_type,
+                                  hash_id,
+                                  is_protected);
+    start_service_context_queue_.push(context);
+
+    connection_handler_observer_->OnServiceStartedCallback(
+        connection->connection_device_handle(),
+        session_key,
+        service_type,
+        params);
+  } else {
+    if (protocol_handler_) {
+      std::vector<std::string> empty;
+      protocol_handler_->NotifySessionStartedResult(
+          new_session_id, hash_id, is_protected, empty);
+    }
+  }
+}
+
+void ConnectionHandlerImpl::NotifyServiceStartedResult(
+    bool result, std::vector<std::string>& rejected_params) {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  ServiceStartedContext context;
+  bool available = start_service_context_queue_.pop(context);
+  if (!available) {
+    LOG4CXX_ERROR(logger_, "context for start service not found!");
+    return;
+  }
+
+  Connection* connection = NULL;
+  {
+    sync_primitives::AutoReadLock lock(connection_list_lock_);
+    ConnectionList::iterator it =
+        connection_list_.find(context.connection_handle_);
+    if (connection_list_.end() == it) {
+      LOG4CXX_ERROR(logger_, "connection not found");
+      return;
     }
+    connection = it->second;
+  }
+
+  if (!result) {
+    LOG4CXX_WARN(logger_,
+                 "Service starting forbidden by connection_handler_observer");
+    if (protocol_handler::kRpc == context.service_type_) {
+      connection->RemoveSession(context.new_session_id_);
+    } else {
+      connection->RemoveService(context.session_id_, context.service_type_);
+    }
+    context.new_session_id_ = 0;
+  }
+
+  if (protocol_handler_ != NULL) {
+    protocol_handler_->NotifySessionStartedResult(context.new_session_id_,
+                                                  context.hash_id_,
+                                                  context.is_protected_,
+                                                  rejected_params);
+  }
+}
+
+void ConnectionHandlerImpl::NotifySessionStartedFailure(bool is_protected) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  if (protocol_handler_) {
+    std::vector<std::string> empty;
+    protocol_handler_->NotifySessionStartedResult(
+        0, protocol_handler::HASH_ID_WRONG, is_protected, empty);
   }
-  return new_session_id;
 }
 
 void ConnectionHandlerImpl::OnApplicationFloodCallBack(
diff --git a/src/components/connection_handler/test/connection_handler_impl_test.cc b/src/components/connection_handler/test/connection_handler_impl_test.cc
index 7f4429500d..a8254af646 100644
--- a/src/components/connection_handler/test/connection_handler_impl_test.cc
+++ b/src/components/connection_handler/test/connection_handler_impl_test.cc
@@ -54,10 +54,18 @@ using namespace ::connection_handler;
 using ::protocol_handler::ServiceType;
 using namespace ::protocol_handler;
 using ::testing::_;
+using ::testing::ByRef;
+using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::ReturnRefOfCopy;
+using ::testing::SaveArg;
+
+// custom action to call a member function with 4 arguments
+ACTION_P4(InvokeMemberFuncWithArg2, ptr, memberFunc, a, b) {
+  (ptr->*memberFunc)(a, b);
+}
 
 namespace {
 const uint32_t kAsyncExpectationsTimeout = 10000u;
@@ -108,8 +116,15 @@ class ConnectionHandlerTest : public ::testing::Test {
     // Remove all specific services
   }
   void AddTestSession() {
-    start_session_id_ = connection_handler_->OnSessionStartedCallback(
-        uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+    protocol_handler_test::MockProtocolHandler temp_protocol_handler;
+    connection_handler_->set_protocol_handler(&temp_protocol_handler);
+    EXPECT_CALL(temp_protocol_handler, NotifySessionStartedResult(_, _, _, _))
+        .WillOnce(
+            DoAll(SaveArg<0>(&start_session_id_), SaveArg<1>(&out_hash_id_)));
+
+    connection_handler_->OnSessionStartedCallback(
+        uid_, 0, kRpc, PROTECTION_OFF, NULL);
+    connection_handler_->set_protocol_handler(NULL);
     EXPECT_NE(0u, start_session_id_);
     EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_);
     connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_);
@@ -123,8 +138,16 @@ class ConnectionHandlerTest : public ::testing::Test {
     EXPECT_EQ(SessionHash(uid_, start_session_id_), out_hash_id_);
     connection_key_ = connection_handler_->KeyFromPair(uid_, start_session_id_);
     CheckSessionExists(uid_, start_session_id_);
-    uint32_t session_id = connection_handler_->OnSessionStartedCallback(
+
+    uint32_t session_id = 0;
+    protocol_handler_test::MockProtocolHandler temp_protocol_handler;
+    connection_handler_->set_protocol_handler(&temp_protocol_handler);
+    EXPECT_CALL(temp_protocol_handler, NotifySessionStartedResult(_, _, _, _))
+        .WillOnce(SaveArg<0>(&session_id));
+
+    connection_handler_->OnSessionStartedCallback(
         uid_, start_session_id_, service_type, PROTECTION_OFF, 0);
+    connection_handler_->set_protocol_handler(NULL);
     EXPECT_EQ(session_id, start_session_id_);
   }
 
@@ -267,8 +290,13 @@ TEST_F(ConnectionHandlerTest, StartSession_NoConnection) {
   // Null sessionId for start new session
   const uint8_t sessionID = 0;
   // Start new session with RPC service
-  const uint32_t result_fail = connection_handler_->OnSessionStartedCallback(
-      uid_, sessionID, kRpc, PROTECTION_ON, &out_hash_id_);
+  uint32_t result_fail = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(DoAll(SaveArg<0>(&result_fail), SaveArg<1>(&out_hash_id_)));
+
+  connection_handler_->OnSessionStartedCallback(
+      uid_, sessionID, kRpc, PROTECTION_ON, NULL);
   // Unknown connection error is '0'
   EXPECT_EQ(0u, result_fail);
   EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
@@ -1013,19 +1041,28 @@ TEST_F(ConnectionHandlerTest, StartService_withServices) {
   AddTestDeviceConnection();
   AddTestSession();
 
+  uint32_t start_audio = 0;
+  uint32_t start_video = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(DoAll(SaveArg<0>(&start_audio), SaveArg<1>(&out_hash_id_)))
+      .WillOnce(DoAll(SaveArg<0>(&start_video), SaveArg<1>(&out_hash_id_)));
+
   // Start Audio service
-  const uint32_t start_audio = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
   EXPECT_EQ(start_session_id_, start_audio);
   CheckServiceExists(uid_, start_session_id_, kAudio, true);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
 
   // Start Audio service
-  const uint32_t start_video = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kMobileNav, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kMobileNav, PROTECTION_OFF, NULL);
   EXPECT_EQ(start_session_id_, start_video);
   CheckServiceExists(uid_, start_session_id_, kMobileNav, true);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
+
+  connection_handler_->set_protocol_handler(NULL);
 }
 
 TEST_F(ConnectionHandlerTest, ServiceStop_UnExistSession) {
@@ -1052,11 +1089,18 @@ TEST_F(ConnectionHandlerTest, ServiceStop_UnExistService) {
 TEST_F(ConnectionHandlerTest, ServiceStop) {
   AddTestDeviceConnection();
   AddTestSession();
+
+  uint32_t start_audio = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillRepeatedly(
+          DoAll(SaveArg<0>(&start_audio), SaveArg<1>(&out_hash_id_)));
+
   // Check ignoring hash_id on stop non-rpc service
   for (uint32_t some_hash_id = 0; some_hash_id < 0xFF; ++some_hash_id) {
     // Start audio service
-    const uint32_t start_audio = connection_handler_->OnSessionStartedCallback(
-        uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+    connection_handler_->OnSessionStartedCallback(
+        uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
     EXPECT_EQ(start_session_id_, start_audio);
     EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
 
@@ -1122,13 +1166,23 @@ TEST_F(ConnectionHandlerTest, SessionStarted_WithRpc) {
       &mock_connection_handler_observer);
   uint32_t session_key =
       connection_handler_->KeyFromPair(uid_, start_session_id_);
+  std::vector<std::string> empty;
   EXPECT_CALL(mock_connection_handler_observer,
-              OnServiceStartedCallback(device_handle_, session_key, kRpc))
-      .WillOnce(Return(true));
+              OnServiceStartedCallback(device_handle_, session_key, kRpc, NULL))
+      .WillOnce(InvokeMemberFuncWithArg2(
+          connection_handler_,
+          &ConnectionHandler::NotifyServiceStartedResult,
+          true,
+          ByRef(empty)));
+
+  uint32_t new_session_id = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(DoAll(SaveArg<0>(&new_session_id), SaveArg<1>(&out_hash_id_)));
 
   // Start new session with RPC service
-  uint32_t new_session_id = connection_handler_->OnSessionStartedCallback(
-      uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, 0, kRpc, PROTECTION_OFF, NULL);
 
   EXPECT_NE(0u, new_session_id);
 }
@@ -1142,10 +1196,17 @@ TEST_F(ConnectionHandlerTest,
   // Forbid start kRPC without encryption
   protected_services_.push_back(kRpc);
   SetSpecificServices();
+
+  uint32_t session_id_fail = 0;
+  uint32_t session_id = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(DoAll(SaveArg<0>(&session_id_fail), SaveArg<1>(&out_hash_id_)))
+      .WillOnce(DoAll(SaveArg<0>(&session_id), SaveArg<1>(&out_hash_id_)));
+
   // Start new session with RPC service
-  const uint32_t session_id_fail =
-      connection_handler_->OnSessionStartedCallback(
-          uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, 0, kRpc, PROTECTION_OFF, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id_fail);
   EXPECT_EQ(protocol_handler::HASH_ID_WRONG, out_hash_id_);
@@ -1159,8 +1220,8 @@ TEST_F(ConnectionHandlerTest,
   protected_services_.push_back(kControl);
   SetSpecificServices();
   // Start new session with RPC service
-  const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid_, 0, kRpc, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, 0, kRpc, PROTECTION_OFF, NULL);
   EXPECT_NE(0u, session_id);
   CheckService(uid_, session_id, kRpc, NULL, PROTECTION_OFF);
   EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_);
@@ -1176,10 +1237,17 @@ TEST_F(ConnectionHandlerTest,
   unprotected_services_.push_back(UnnamedService::kServedService2);
   unprotected_services_.push_back(kControl);
   SetSpecificServices();
+
+  uint32_t session_id_fail = 0;
+  uint32_t session_id = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id_fail))
+      .WillOnce(DoAll(SaveArg<0>(&session_id), SaveArg<1>(&out_hash_id_)));
+
   // Start new session with RPC service
-  const uint32_t session_id_fail =
-      connection_handler_->OnSessionStartedCallback(
-          uid_, 0, kRpc, PROTECTION_ON, NULL);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, 0, kRpc, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id_fail);
 #else
@@ -1191,8 +1259,8 @@ TEST_F(ConnectionHandlerTest,
   unprotected_services_.push_back(kControl);
   SetSpecificServices();
   // Start new session with RPC service
-  const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
-      uid_, 0, kRpc, PROTECTION_ON, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, 0, kRpc, PROTECTION_ON, NULL);
   EXPECT_NE(0u, session_id);
   EXPECT_EQ(SessionHash(uid_, session_id), out_hash_id_);
 
@@ -1211,8 +1279,16 @@ TEST_F(ConnectionHandlerTest,
   protected_services_.push_back(UnnamedService::kServedService2);
   protected_services_.push_back(kControl);
   SetSpecificServices();
+
+  uint32_t session_id2 = 0;
+  uint32_t session_id3 = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id2))
+      .WillOnce(DoAll(SaveArg<0>(&session_id3), SaveArg<1>(&out_hash_id_)));
+
   // Start new session with Audio service
-  const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback(
+  connection_handler_->OnSessionStartedCallback(
       uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id2);
@@ -1226,8 +1302,8 @@ TEST_F(ConnectionHandlerTest,
   protected_services_.push_back(UnnamedService::kServedService2);
   protected_services_.push_back(kControl);
   SetSpecificServices();
-  const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
 // Returned original session id
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(start_session_id_, session_id3);
@@ -1250,10 +1326,17 @@ TEST_F(ConnectionHandlerTest,
   unprotected_services_.push_back(UnnamedService::kServedService2);
   unprotected_services_.push_back(kControl);
   SetSpecificServices();
+
+  uint32_t session_id_reject = 0;
+  uint32_t session_id3 = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id_reject))
+      .WillOnce(DoAll(SaveArg<0>(&session_id3), SaveArg<1>(&out_hash_id_)));
+
   // Start new session with Audio service
-  const uint32_t session_id_reject =
-      connection_handler_->OnSessionStartedCallback(
-          uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(0u, session_id_reject);
 #else
@@ -1262,8 +1345,8 @@ TEST_F(ConnectionHandlerTest,
   // Allow start kAudio with encryption
   unprotected_services_.clear();
   SetSpecificServices();
-  const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
 // Returned original session id
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(start_session_id_, session_id3);
@@ -1280,9 +1363,18 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) {
   AddTestDeviceConnection();
   AddTestSession();
 
+  uint32_t session_id_new = 0;
+  uint32_t session_id2 = 0;
+  uint32_t session_id3 = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(DoAll(SaveArg<0>(&session_id_new), SaveArg<1>(&out_hash_id_)))
+      .WillOnce(DoAll(SaveArg<0>(&session_id2), SaveArg<1>(&out_hash_id_)))
+      .WillOnce(DoAll(SaveArg<0>(&session_id3), SaveArg<1>(&out_hash_id_)));
+
   // Start RPC protection
-  const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kRpc, PROTECTION_ON, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kRpc, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(start_session_id_, session_id_new);
   // Post protection nedd no hash
@@ -1296,15 +1388,15 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtect) {
 #endif  // ENABLE_SECURITY
 
   // Start Audio session without protection
-  const uint32_t session_id2 = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kAudio, PROTECTION_OFF, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kAudio, PROTECTION_OFF, NULL);
   EXPECT_EQ(start_session_id_, session_id2);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
   CheckService(uid_, start_session_id_, kAudio, NULL, PROTECTION_OFF);
 
   // Start Audio protection
-  const uint32_t session_id3 = connection_handler_->OnSessionStartedCallback(
-      uid_, start_session_id_, kAudio, PROTECTION_ON, &out_hash_id_);
+  connection_handler_->OnSessionStartedCallback(
+      uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(start_session_id_, session_id3);
   EXPECT_EQ(protocol_handler::HASH_ID_NOT_SUPPORTED, out_hash_id_);
@@ -1320,7 +1412,11 @@ TEST_F(ConnectionHandlerTest, SessionStarted_DealyProtectBulk) {
   AddTestDeviceConnection();
   AddTestSession();
 
-  const uint32_t session_id_new = connection_handler_->OnSessionStartedCallback(
+  uint32_t session_id_new = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id_new));
+  connection_handler_->OnSessionStartedCallback(
       uid_, start_session_id_, kBulk, PROTECTION_ON, NULL);
 #ifdef ENABLE_SECURITY
   EXPECT_EQ(start_session_id_, session_id_new);
@@ -1416,8 +1512,14 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByProtectedService) {
   // kAudio is not exists yet
   EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kAudio),
             reinterpret_cast<security_manager::SSLContext*>(NULL));
+
+  uint32_t session_id = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id));
+
   // Open kAudio service
-  const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
+  connection_handler_->OnSessionStartedCallback(
       uid_, start_session_id_, kAudio, PROTECTION_ON, NULL);
   EXPECT_EQ(session_id, start_session_id_);
   CheckService(uid_, session_id, kAudio, &mock_ssl_context, PROTECTION_ON);
@@ -1441,8 +1543,13 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedRPC) {
   EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
             reinterpret_cast<security_manager::SSLContext*>(NULL));
 
+  uint32_t session_id = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id));
+
   // Protect kRpc (Bulk will be protect also)
-  const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
+  connection_handler_->OnSessionStartedCallback(
       uid_, start_session_id_, kRpc, PROTECTION_ON, NULL);
   EXPECT_EQ(start_session_id_, session_id);
   CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON);
@@ -1469,8 +1576,13 @@ TEST_F(ConnectionHandlerTest, GetSSLContext_ByDealyProtectedBulk) {
   EXPECT_EQ(connection_handler_->GetSSLContext(connection_key_, kRpc),
             reinterpret_cast<security_manager::SSLContext*>(NULL));
 
+  uint32_t session_id = 0;
+  connection_handler_->set_protocol_handler(&mock_protocol_handler_);
+  EXPECT_CALL(mock_protocol_handler_, NotifySessionStartedResult(_, _, _, _))
+      .WillOnce(SaveArg<0>(&session_id));
+
   // Protect Bulk (kRpc will be protected also)
-  const uint32_t session_id = connection_handler_->OnSessionStartedCallback(
+  connection_handler_->OnSessionStartedCallback(
       uid_, start_session_id_, kBulk, PROTECTION_ON, NULL);
   EXPECT_EQ(start_session_id_, session_id);
   CheckService(uid_, session_id, kRpc, &mock_ssl_context, PROTECTION_ON);
diff --git a/src/components/include/application_manager/application_manager.h b/src/components/include/application_manager/application_manager.h
index 98bb341657..7875c12ff5 100644
--- a/src/components/include/application_manager/application_manager.h
+++ b/src/components/include/application_manager/application_manager.h
@@ -592,6 +592,20 @@ class ApplicationManager {
    */
   virtual void ForbidStreaming(uint32_t app_id) = 0;
 
+  /**
+   * @brief Called when application completes streaming configuration
+   * @param app_id Streaming application id
+   * @param service_type Streaming service type
+   * @param result true if configuration is successful, false otherwise
+   * @param rejected_params list of rejected parameters' name. Valid
+   *                        only when result is false.
+   */
+  virtual void OnStreamingConfigured(
+      uint32_t app_id,
+      protocol_handler::ServiceType service_type,
+      bool result,
+      std::vector<std::string>& rejected_params) = 0;
+
   virtual const ApplicationManagerSettings& get_settings() const = 0;
 
   virtual event_engine::EventDispatcher& event_dispatcher() = 0;
diff --git a/src/components/include/connection_handler/connection_handler.h b/src/components/include/connection_handler/connection_handler.h
index e8e1af715a..ca1a0314c6 100644
--- a/src/components/include/connection_handler/connection_handler.h
+++ b/src/components/include/connection_handler/connection_handler.h
@@ -198,6 +198,18 @@ class ConnectionHandler {
 
   virtual DevicesDiscoveryStarter& get_device_discovery_starter() = 0;
 
+  /**
+   * \brief Invoked when observer's OnServiceStartedCallback is completed
+   * \param result true if observer accepts starting service, false otherwise
+   * \param rejected_params list of rejected parameters' name. Only valid when
+   * result is false. Note that even if result is false, this may be empty.
+   *
+   * \note This is invoked only once but can be invoked by multiple threads.
+   * Also it can be invoked before OnServiceStartedCallback() returns.
+   **/
+  virtual void NotifyServiceStartedResult(
+      bool result, std::vector<std::string>& rejected_params) = 0;
+
  protected:
   /**
    * \brief Destructor
diff --git a/src/components/include/connection_handler/connection_handler_observer.h b/src/components/include/connection_handler/connection_handler_observer.h
index e25b0aaea5..706f338d60 100644
--- a/src/components/include/connection_handler/connection_handler_observer.h
+++ b/src/components/include/connection_handler/connection_handler_observer.h
@@ -42,6 +42,8 @@
 #include "security_manager/ssl_context.h"
 #endif  // ENABLE_SECURITY
 
+struct BsonObject;
+
 /**
  * \namespace connection_handler
  * \brief SmartDeviceLink connection_handler namespace.
@@ -83,15 +85,18 @@ class ConnectionHandlerObserver {
   /**
    * \brief Callback function used by connection_handler
    * when Mobile Application initiates start of new service.
+   * Result must be notified through NotifyServiceStartedResult().
    * \param deviceHandle Device identifier within which session has to be
    * started.
    * \param sessionKey Key of started session.
    * \param type Established service type
+   * \param params Configuration parameters for this service
    */
-  virtual bool OnServiceStartedCallback(
+  virtual void OnServiceStartedCallback(
       const connection_handler::DeviceHandle& device_handle,
       const int32_t& session_key,
-      const protocol_handler::ServiceType& type) = 0;
+      const protocol_handler::ServiceType& type,
+      const BsonObject* params) = 0;
 
   /**
    * \brief Callback function used by connection_handler
diff --git a/src/components/include/protocol_handler/protocol_handler.h b/src/components/include/protocol_handler/protocol_handler.h
index 183db21532..5a3a2754cb 100644
--- a/src/components/include/protocol_handler/protocol_handler.h
+++ b/src/components/include/protocol_handler/protocol_handler.h
@@ -108,6 +108,23 @@ class ProtocolHandler {
   virtual const ProtocolHandlerSettings& get_settings() const = 0;
   virtual SessionObserver& get_session_observer() = 0;
 
+  /**
+   * \brief Called by connection handler to notify the result of
+   * OnSessionStartedCallback().
+   * \param session_id Generated session ID, will be 0 if session is not
+   * started
+   * \param hash_id Generated Hash ID
+   * \param protection whether the service will be protected
+   * \param rejected_params list of parameters' name that are rejected.
+   * Only valid when session_id is 0. Note, even if session_id is 0, the
+   * list may be empty.
+   */
+  virtual void NotifySessionStartedResult(
+      uint8_t session_id,
+      uint32_t hash_id,
+      bool protection,
+      std::vector<std::string>& rejected_params) = 0;
+
  protected:
   /**
    * \brief Destructor
diff --git a/src/components/include/protocol_handler/session_observer.h b/src/components/include/protocol_handler/session_observer.h
index a5901baf0b..70035b5a3c 100644
--- a/src/components/include/protocol_handler/session_observer.h
+++ b/src/components/include/protocol_handler/session_observer.h
@@ -39,6 +39,9 @@
 #ifdef ENABLE_SECURITY
 #include "security_manager/ssl_context.h"
 #endif  // ENABLE_SECURITY
+
+struct BsonObject;
+
         /**
          *\namespace protocol_handlerHandler
          *\brief Namespace for SmartDeviceLink ProtocolHandler related functionality.
@@ -64,21 +67,21 @@ class SessionObserver {
   /**
    * \brief Callback function used by ProtocolHandler
    * when Mobile Application initiates start of new session.
+   * Result must be notified through NotifySessionStartedResult().
    * \param connection_handle Connection identifier within which session
    * has to be started.
    * \param sessionId Identifier of the session to be start
    * \param service_type Type of service
    * \param protocol_version Version of protocol
    * \param is_protected would be service protected
-   * \param hash_id pointer for session hash identifier, uint32_t* hash_id
-   * \return uint32_t Id (number) of new session if successful, otherwise 0.
+   * \param params configuration parameters specified by mobile
    */
-  virtual uint32_t OnSessionStartedCallback(
+  virtual void OnSessionStartedCallback(
       const transport_manager::ConnectionUID connection_handle,
       const uint8_t sessionId,
       const protocol_handler::ServiceType& service_type,
       const bool is_protected,
-      uint32_t* hash_id) = 0;
+      const BsonObject *params) = 0;
 
   // DEPRECATED
   virtual uint32_t OnSessionEndedCallback(
diff --git a/src/components/include/test/application_manager/mock_application_manager.h b/src/components/include/test/application_manager/mock_application_manager.h
index fb15435ca0..8d1bb756c2 100644
--- a/src/components/include/test/application_manager/mock_application_manager.h
+++ b/src/components/include/test/application_manager/mock_application_manager.h
@@ -261,6 +261,11 @@ class MockApplicationManager : public application_manager::ApplicationManager {
   MOCK_METHOD0(OnTimerSendTTSGlobalProperties, void());
   MOCK_METHOD0(OnLowVoltage, void());
   MOCK_METHOD0(OnWakeUp, void());
+  MOCK_METHOD4(OnStreamingConfigured,
+               void(uint32_t app_id,
+                    protocol_handler::ServiceType service_type,
+                    bool result,
+                    std::vector<std::string>& rejected_params));
 };
 
 }  // namespace application_manager_test
diff --git a/src/components/include/test/connection_handler/mock_connection_handler.h b/src/components/include/test/connection_handler/mock_connection_handler.h
index e17224b097..b6af1e1f15 100644
--- a/src/components/include/test/connection_handler/mock_connection_handler.h
+++ b/src/components/include/test/connection_handler/mock_connection_handler.h
@@ -96,6 +96,8 @@ class MockConnectionHandler : public connection_handler::ConnectionHandler {
   MOCK_METHOD0(get_device_discovery_starter, DevicesDiscoveryStarter&());
   MOCK_CONST_METHOD1(GetConnectedDevicesMAC,
                      void(std::vector<std::string>& macs));
+  MOCK_METHOD2(NotifyServiceStartedResult,
+               void(bool result, std::vector<std::string>& rejected_params));
 };
 
 }  // namespace connection_handler_test
diff --git a/src/components/include/test/connection_handler/mock_connection_handler_observer.h b/src/components/include/test/connection_handler/mock_connection_handler_observer.h
index 6ca4557b35..d9a12d35c2 100644
--- a/src/components/include/test/connection_handler/mock_connection_handler_observer.h
+++ b/src/components/include/test/connection_handler/mock_connection_handler_observer.h
@@ -48,10 +48,11 @@ class MockConnectionHandlerObserver
   MOCK_METHOD0(OnFindNewApplicationsRequest, void());
   MOCK_METHOD1(RemoveDevice,
                void(const connection_handler::DeviceHandle& device_handle));
-  MOCK_METHOD3(OnServiceStartedCallback,
-               bool(const connection_handler::DeviceHandle& device_handle,
+  MOCK_METHOD4(OnServiceStartedCallback,
+               void(const connection_handler::DeviceHandle& device_handle,
                     const int32_t& session_key,
-                    const protocol_handler::ServiceType& type));
+                    const protocol_handler::ServiceType& type,
+                    const BsonObject* params));
   MOCK_METHOD3(
       OnServiceEndedCallback,
       void(const int32_t& session_key,
diff --git a/src/components/include/test/protocol_handler/mock_protocol_handler.h b/src/components/include/test/protocol_handler/mock_protocol_handler.h
index 44287edd4d..acb06ea6df 100644
--- a/src/components/include/test/protocol_handler/mock_protocol_handler.h
+++ b/src/components/include/test/protocol_handler/mock_protocol_handler.h
@@ -62,6 +62,11 @@ class MockProtocolHandler : public ::protocol_handler::ProtocolHandler {
   MOCK_CONST_METHOD0(get_settings,
                      const ::protocol_handler::ProtocolHandlerSettings&());
   MOCK_METHOD0(get_session_observer, protocol_handler::SessionObserver&());
+  MOCK_METHOD4(NotifySessionStartedResult,
+               void(uint8_t session_id,
+                    uint32_t hash_id,
+                    bool protection,
+                    std::vector<std::string>& rejected_params));
 };
 }  // namespace protocol_handler_test
 }  // namespace components
diff --git a/src/components/include/test/protocol_handler/mock_session_observer.h b/src/components/include/test/protocol_handler/mock_session_observer.h
index 0a86a29db5..40137c2e00 100644
--- a/src/components/include/test/protocol_handler/mock_session_observer.h
+++ b/src/components/include/test/protocol_handler/mock_session_observer.h
@@ -46,13 +46,12 @@ namespace protocol_handler_test {
  */
 class MockSessionObserver : public ::protocol_handler::SessionObserver {
  public:
-  MOCK_METHOD5(
-      OnSessionStartedCallback,
-      uint32_t(const transport_manager::ConnectionUID connection_handle,
-               const uint8_t sessionId,
-               const protocol_handler::ServiceType& service_type,
-               const bool is_protected,
-               uint32_t* hash_id));
+  MOCK_METHOD5(OnSessionStartedCallback,
+               void(const transport_manager::ConnectionUID connection_handle,
+                    const uint8_t sessionId,
+                    const protocol_handler::ServiceType& service_type,
+                    const bool is_protected,
+                    const BsonObject* params));
   MOCK_METHOD4(
       OnSessionEndedCallback,
       uint32_t(const transport_manager::ConnectionUID connection_handle,
diff --git a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h
index bb6483dd82..2370fd730f 100644
--- a/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h
+++ b/src/components/protocol_handler/include/protocol_handler/protocol_handler_impl.h
@@ -349,6 +349,23 @@ class ProtocolHandlerImpl
 
   SessionObserver& get_session_observer() OVERRIDE;
 
+  /**
+   * \brief Called by connection handler to notify the result of
+   * OnSessionStartedCallback().
+   * \param session_id Generated session ID, will be 0 if session is not
+   * started
+   * \param hash_id Generated Hash ID
+   * \param protection whether the service will be protected
+   * \param rejected_params list of parameters' name that are rejected.
+   * Only valid when session_id is 0. Note, even if session_id is 0, the
+   * list may be empty.
+   */
+  void NotifySessionStartedResult(
+      uint8_t session_id,
+      uint32_t hash_id,
+      bool protection,
+      std::vector<std::string>& rejected_params) OVERRIDE;
+
 #ifdef BUILD_TESTS
   const impl::FromMobileQueue& get_from_mobile_queue() const {
     return raw_ford_messages_from_mobile_;
@@ -505,7 +522,7 @@ class ProtocolHandlerImpl
 
   RESULT_CODE HandleControlMessageEndServiceACK(const ProtocolPacket& packet);
 
-  RESULT_CODE HandleControlMessageStartSession(const ProtocolPacket& packet);
+  RESULT_CODE HandleControlMessageStartSession(const ProtocolFramePtr packet);
 
   RESULT_CODE HandleControlMessageHeartBeat(const ProtocolPacket& packet);
 
@@ -618,6 +635,9 @@ class ProtocolHandlerImpl
 
   sync_primitives::Lock protocol_observers_lock_;
 
+  // we need thread-safe queue
+  utils::MessageQueue<ProtocolFramePtr> start_session_frame_queue_;
+
 #ifdef TELEMETRY_MONITOR
   PHTelemetryObserver* metric_observer_;
 #endif  // TELEMETRY_MONITOR
diff --git a/src/components/protocol_handler/src/protocol_handler_impl.cc b/src/components/protocol_handler/src/protocol_handler_impl.cc
index 938583125d..3592ce692d 100644
--- a/src/components/protocol_handler/src/protocol_handler_impl.cc
+++ b/src/components/protocol_handler/src/protocol_handler_impl.cc
@@ -81,6 +81,7 @@ ProtocolHandlerImpl::ProtocolHandlerImpl(
         "PH FromMobile", this, threads::ThreadOptions(kStackSize))
     , raw_ford_messages_to_mobile_(
           "PH ToMobile", this, threads::ThreadOptions(kStackSize))
+    , start_session_frame_queue_()
 #ifdef TELEMETRY_MONITOR
     , metric_observer_(NULL)
 #endif  // TELEMETRY_MONITOR
@@ -1029,7 +1030,7 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessage(
   switch (packet->frame_data()) {
     case FRAME_DATA_START_SERVICE: {
       LOG4CXX_TRACE(logger_, "FrameData: StartService");
-      return HandleControlMessageStartSession(*packet);
+      return HandleControlMessageStartSession(packet);
     }
     case FRAME_DATA_END_SERVICE: {
       LOG4CXX_TRACE(logger_, "FrameData: StopService");
@@ -1253,37 +1254,63 @@ class StartSessionHandler : public security_manager::SecurityManagerListener {
 #endif  // ENABLE_SECURITY
 
 RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
-    const ProtocolPacket& packet) {
+    const ProtocolFramePtr packet) {
   LOG4CXX_AUTO_TRACE(logger_);
   LOG4CXX_DEBUG(
       logger_,
-      "Protocol version:" << static_cast<int>(packet.protocol_version()));
-  const ServiceType service_type = ServiceTypeFromByte(packet.service_type());
-  const uint8_t protocol_version = packet.protocol_version();
+      "Protocol version:" << static_cast<int>(packet->protocol_version()));
+  const ServiceType service_type = ServiceTypeFromByte(packet->service_type());
+  const uint8_t protocol_version = packet->protocol_version();
+  BsonObject bson_obj = bson_object_from_bytes(packet->data());
 
 #ifdef ENABLE_SECURITY
   const bool protection =
       // Protocolo version 1 is not support protection
-      (protocol_version > PROTOCOL_VERSION_1) ? packet.protection_flag()
+      (protocol_version > PROTOCOL_VERSION_1) ? packet->protection_flag()
                                               : false;
 #else
   const bool protection = false;
 #endif  // ENABLE_SECURITY
 
-  uint32_t hash_id;
-  const ConnectionID connection_id = packet.connection_id();
-  const uint32_t session_id = session_observer_.OnSessionStartedCallback(
-      connection_id, packet.session_id(), service_type, protection, &hash_id);
+  const ConnectionID connection_id = packet->connection_id();
+
+  start_session_frame_queue_.push(packet);
+
+  session_observer_.OnSessionStartedCallback(
+      connection_id, packet->session_id(), service_type, protection, &bson_obj);
+  bson_object_deinitialize(&bson_obj);
+
+  return RESULT_OK;
+}
+
+void ProtocolHandlerImpl::NotifySessionStartedResult(
+    uint8_t session_id,
+    uint32_t hash_id,
+    bool protection,
+    std::vector<std::string>& rejected_params) {
+
+  ProtocolFramePtr packet;
+  bool available = start_session_frame_queue_.pop(packet);
+  if (!available) {
+    LOG4CXX_ERROR(logger_,
+                 "Cannot find Session Started packet");
+    return;
+  }
+
+  const ServiceType service_type = ServiceTypeFromByte(packet->service_type());
+  const uint8_t protocol_version = packet->protocol_version();
+  const ConnectionID connection_id = packet->connection_id();
 
   if (0 == session_id) {
     LOG4CXX_WARN(logger_,
                  "Refused by session_observer to create service "
                      << static_cast<int32_t>(service_type) << " type.");
     SendStartSessionNAck(connection_id,
-                         packet.session_id(),
+                         session_id,
                          protocol_version,
-                         packet.service_type());
-    return RESULT_OK;
+                         packet->service_type(),
+                         rejected_params);
+    return;
   }
 
 #ifdef ENABLE_SECURITY
@@ -1304,19 +1331,19 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
       // Start service without protection
       SendStartSessionAck(connection_id,
                           session_id,
-                          packet.protocol_version(),
+                          packet->protocol_version(),
                           hash_id,
-                          packet.service_type(),
+                          packet->service_type(),
                           PROTECTION_OFF);
-      return RESULT_OK;
+      return;
     }
     ProtocolPacket::ProtocolVersion* fullVersion;
     std::vector<std::string> rejectedParams;
     // Can't check protocol_version because the first packet is v1, but there
     // could still be a payload, in which case we can get the real protocol
     // version
-    if (packet.service_type() == kRpc && packet.data_size() != 0) {
-      BsonObject obj = bson_object_from_bytes(packet.data());
+    if (packet->service_type() == kRpc && packet->data_size() != 0) {
+      BsonObject obj = bson_object_from_bytes(packet->data());
       fullVersion = new ProtocolPacket::ProtocolVersion(
           std::string(bson_object_get_string(&obj, strings::protocol_version)));
       bson_object_deinitialize(&obj);
@@ -1329,9 +1356,9 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
     }
     if (!rejectedParams.empty()) {
       SendStartSessionNAck(connection_id,
-                           packet.session_id(),
+                           packet->session_id(),
                            protocol_version,
-                           packet.service_type(),
+                           packet->service_type(),
                            rejectedParams);
     } else if (ssl_context->IsInitCompleted()) {
       // mark service as protected
@@ -1339,9 +1366,9 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
       // Start service as protected with current SSLContext
       SendStartSessionAck(connection_id,
                           session_id,
-                          packet.protocol_version(),
+                          packet->protocol_version(),
                           hash_id,
-                          packet.service_type(),
+                          packet->service_type(),
                           PROTECTION_ON,
                           *fullVersion);
     } else {
@@ -1351,7 +1378,7 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
                                   session_observer_,
                                   connection_id,
                                   session_id,
-                                  packet.protocol_version(),
+                                  packet->protocol_version(),
                                   hash_id,
                                   service_type,
                                   get_settings().force_protected_service(),
@@ -1365,11 +1392,11 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
     LOG4CXX_DEBUG(logger_,
                   "Protection establishing for connection "
                       << connection_key << " is in progress");
-    return RESULT_OK;
+    return;
   }
 #endif  // ENABLE_SECURITY
-  if (packet.service_type() == kRpc && packet.data_size() != 0) {
-    BsonObject obj = bson_object_from_bytes(packet.data());
+  if (packet->service_type() == kRpc && packet->data_size() != 0) {
+    BsonObject obj = bson_object_from_bytes(packet->data());
     ProtocolPacket::ProtocolVersion fullVersion(
         bson_object_get_string(&obj, strings::protocol_version));
     bson_object_deinitialize(&obj);
@@ -1378,18 +1405,18 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
       // Start service without protection
       SendStartSessionAck(connection_id,
                           session_id,
-                          packet.protocol_version(),
+                          packet->protocol_version(),
                           hash_id,
-                          packet.service_type(),
+                          packet->service_type(),
                           PROTECTION_OFF,
                           fullVersion);
     } else {
       std::vector<std::string> rejectedParams(
           1, std::string(strings::protocol_version));
       SendStartSessionNAck(connection_id,
-                           packet.session_id(),
+                           packet->session_id(),
                            protocol_version,
-                           packet.service_type(),
+                           packet->service_type(),
                            rejectedParams);
     }
 
@@ -1397,12 +1424,11 @@ RESULT_CODE ProtocolHandlerImpl::HandleControlMessageStartSession(
     // Start service without protection
     SendStartSessionAck(connection_id,
                         session_id,
-                        packet.protocol_version(),
+                        packet->protocol_version(),
                         hash_id,
-                        packet.service_type(),
+                        packet->service_type(),
                         PROTECTION_OFF);
   }
-  return RESULT_OK;
 }
 
 RESULT_CODE ProtocolHandlerImpl::HandleControlMessageHeartBeat(
diff --git a/src/components/protocol_handler/test/protocol_handler_tm_test.cc b/src/components/protocol_handler/test/protocol_handler_tm_test.cc
index 66226825ba..2729254869 100644
--- a/src/components/protocol_handler/test/protocol_handler_tm_test.cc
+++ b/src/components/protocol_handler/test/protocol_handler_tm_test.cc
@@ -98,6 +98,7 @@ using ::testing::ReturnRefOfCopy;
 using ::testing::ReturnNull;
 using ::testing::An;
 using ::testing::AnyOf;
+using ::testing::ByRef;
 using ::testing::DoAll;
 using ::testing::_;
 using ::testing::Invoke;
@@ -106,6 +107,11 @@ using ::testing::SetArgPointee;
 
 typedef std::vector<uint8_t> UCharDataVector;
 
+// custom action to call a member function with 4 arguments
+ACTION_P6(InvokeMemberFuncWithArg4, ptr, memberFunc, a, b, c, d) {
+  (ptr->*memberFunc)(a, b, c, d);
+}
+
 namespace {
 const uint32_t kAsyncExpectationsTimeout = 10000u;
 }
@@ -179,6 +185,7 @@ class ProtocolHandlerImplTest : public ::testing::Test {
 
   void AddSession(const ::utils::SharedPtr<TestAsyncWaiter>& waiter,
                   uint32_t& times) {
+    using namespace protocol_handler;
     ASSERT_TRUE(NULL != waiter.get());
 
     AddConnection();
@@ -192,6 +199,7 @@ class ProtocolHandlerImplTest : public ::testing::Test {
     // use protection OFF
     const bool callback_protection_flag = PROTECTION_OFF;
 #endif  // ENABLE_SECURITY
+    std::vector<std::string> empty;
 
     // Expect ConnectionHandler check
     EXPECT_CALL(session_observer_mock,
@@ -202,7 +210,14 @@ class ProtocolHandlerImplTest : public ::testing::Test {
                                          _))
         .
         // Return sessions start success
-        WillOnce(DoAll(NotifyTestAsyncWaiter(waiter), Return(session_id)));
+        WillOnce(DoAll(NotifyTestAsyncWaiter(waiter),
+                       InvokeMemberFuncWithArg4(
+                           protocol_handler_impl.get(),
+                           &ProtocolHandler::NotifySessionStartedResult,
+                           session_id,
+                           HASH_ID_WRONG,
+                           callback_protection_flag,
+                           ByRef(empty))));
     times++;
 
     // Expect send Ack with PROTECTION_OFF (on no Security Manager)
@@ -342,11 +357,13 @@ TEST_F(ProtocolHandlerImplTest, RecieveOnUnknownConnection) {
  */
 TEST_F(ProtocolHandlerImplTest,
        StartSession_Unprotected_SessionObserverReject) {
+  using namespace protocol_handler;
   const int call_times = 5;
   AddConnection();
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -358,8 +375,14 @@ TEST_F(ProtocolHandlerImplTest,
       .Times(call_times)
       .
       // Return sessions start rejection
-      WillRepeatedly(
-          DoAll(NotifyTestAsyncWaiter(&waiter), Return(SESSION_START_REJECT)));
+      WillRepeatedly(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   SESSION_START_REJECT,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_OFF,
+                                   ByRef(empty))));
   times += call_times;
 
   // Expect send NAck
@@ -390,6 +413,7 @@ TEST_F(ProtocolHandlerImplTest,
  * OFF
  */
 TEST_F(ProtocolHandlerImplTest, StartSession_Protected_SessionObserverReject) {
+  using namespace protocol_handler;
   const int call_times = 5;
   AddConnection();
 #ifdef ENABLE_SECURITY
@@ -403,6 +427,7 @@ TEST_F(ProtocolHandlerImplTest, StartSession_Protected_SessionObserverReject) {
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -414,8 +439,14 @@ TEST_F(ProtocolHandlerImplTest, StartSession_Protected_SessionObserverReject) {
       .Times(call_times)
       .
       // Return sessions start rejection
-      WillRepeatedly(
-          DoAll(NotifyTestAsyncWaiter(&waiter), Return(SESSION_START_REJECT)));
+      WillRepeatedly(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   SESSION_START_REJECT,
+                                   HASH_ID_WRONG,
+                                   callback_protection_flag,
+                                   ByRef(empty))));
   times += call_times;
 
   // Expect send NAck with encryption OFF
@@ -445,11 +476,13 @@ TEST_F(ProtocolHandlerImplTest, StartSession_Protected_SessionObserverReject) {
  */
 TEST_F(ProtocolHandlerImplTest,
        StartSession_Unprotected_SessionObserverAccept) {
+  using namespace protocol_handler;
   AddConnection();
   const ServiceType start_service = kRpc;
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -457,7 +490,14 @@ TEST_F(ProtocolHandlerImplTest,
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_OFF, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_OFF,
+                                   ByRef(empty))));
   times++;
 
   SetProtocolVersion2();
@@ -567,6 +607,7 @@ TEST_F(ProtocolHandlerImplTest, EndSession_Success) {
  * Check session_observer with PROTECTION_OFF and Ack with PROTECTION_OFF
  */
 TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtocoloV1) {
+  using namespace protocol_handler;
   ::utils::SharedPtr<TestAsyncWaiter> waiter =
       utils::MakeShared<TestAsyncWaiter>();
   uint32_t times = 0;
@@ -576,6 +617,7 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtocoloV1) {
   // Add security manager
   AddSecurityManager();
   const ServiceType start_service = kRpc;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -583,7 +625,14 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtocoloV1) {
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_OFF, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_OFF,
+                                   ByRef(empty))));
   times++;
 
   SetProtocolVersion2();
@@ -612,6 +661,7 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtocoloV1) {
  * PROTECTION_OFF
  */
 TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionUnprotected) {
+  using namespace protocol_handler;
   AddConnection();
   // Add security manager
   AddSecurityManager();
@@ -619,6 +669,7 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionUnprotected) {
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -626,7 +677,14 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionUnprotected) {
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_OFF, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_OFF,
+                                   ByRef(empty))));
   times++;
 
   SetProtocolVersion2();
@@ -646,12 +704,14 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionUnprotected) {
  * ProtocolHandler shall send Ack with PROTECTION_OFF on fail SLL creation
  */
 TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtected_Fail) {
+  using namespace protocol_handler;
   AddConnection();
   AddSecurityManager();
   const ServiceType start_service = kRpc;
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -659,7 +719,14 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtected_Fail) {
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_ON, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_ON,
+                                   ByRef(empty))));
   times++;
 
   SetProtocolVersion2();
@@ -688,12 +755,14 @@ TEST_F(ProtocolHandlerImplTest, SecurityEnable_StartSessionProtected_Fail) {
  */
 TEST_F(ProtocolHandlerImplTest,
        SecurityEnable_StartSessionProtected_SSLInitialized) {
+  using namespace protocol_handler;
   AddConnection();
   AddSecurityManager();
   const ServiceType start_service = kRpc;
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -701,7 +770,14 @@ TEST_F(ProtocolHandlerImplTest,
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_ON, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_ON,
+                                   ByRef(empty))));
   times++;
 
   SetProtocolVersion2();
@@ -743,12 +819,14 @@ TEST_F(ProtocolHandlerImplTest,
  */
 TEST_F(ProtocolHandlerImplTest,
        SecurityEnable_StartSessionProtected_HandshakeFail) {
+  using namespace protocol_handler;
   AddConnection();
   AddSecurityManager();
   const ServiceType start_service = kRpc;
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -756,7 +834,14 @@ TEST_F(ProtocolHandlerImplTest,
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_ON, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_ON,
+                                   ByRef(empty))));
   times++;
 
   std::vector<int> services;
@@ -818,6 +903,7 @@ TEST_F(ProtocolHandlerImplTest,
  */
 TEST_F(ProtocolHandlerImplTest,
        SecurityEnable_StartSessionProtected_HandshakeSuccess) {
+  using namespace protocol_handler;
   AddConnection();
   AddSecurityManager();
   const ServiceType start_service = kRpc;
@@ -829,6 +915,7 @@ TEST_F(ProtocolHandlerImplTest,
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -836,7 +923,14 @@ TEST_F(ProtocolHandlerImplTest,
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_ON, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_ON,
+                                   ByRef(empty))));
   times++;
 
   // call new SSLContext creation
@@ -904,6 +998,7 @@ TEST_F(ProtocolHandlerImplTest,
 TEST_F(
     ProtocolHandlerImplTest,
     SecurityEnable_StartSessionProtected_HandshakeSuccess_ServiceProtectedBefore) {
+  using namespace protocol_handler;
   AddConnection();
   AddSecurityManager();
   const ServiceType start_service = kRpc;
@@ -914,6 +1009,7 @@ TEST_F(
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -921,7 +1017,14 @@ TEST_F(
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_ON, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_ON,
+                                   ByRef(empty))));
   times++;
 
   // call new SSLContext creation
@@ -987,6 +1090,7 @@ TEST_F(
  */
 TEST_F(ProtocolHandlerImplTest,
        SecurityEnable_StartSessionProtected_HandshakeSuccess_SSLIsNotPending) {
+  using namespace protocol_handler;
   AddConnection();
   AddSecurityManager();
   const ServiceType start_service = kRpc;
@@ -997,6 +1101,7 @@ TEST_F(ProtocolHandlerImplTest,
 
   TestAsyncWaiter waiter;
   uint32_t times = 0;
+  std::vector<std::string> empty;
   // Expect ConnectionHandler check
   EXPECT_CALL(
       session_observer_mock,
@@ -1004,7 +1109,14 @@ TEST_F(ProtocolHandlerImplTest,
           connection_id, NEW_SESSION_ID, start_service, PROTECTION_ON, _))
       .
       // Return sessions start success
-      WillOnce(DoAll(NotifyTestAsyncWaiter(&waiter), Return(session_id)));
+      WillOnce(DoAll(
+          NotifyTestAsyncWaiter(&waiter),
+          InvokeMemberFuncWithArg4(protocol_handler_impl.get(),
+                                   &ProtocolHandler::NotifySessionStartedResult,
+                                   session_id,
+                                   HASH_ID_WRONG,
+                                   PROTECTION_ON,
+                                   ByRef(empty))));
   times++;
 
   // call new SSLContext creation