1 files changed, 218 insertions, 120 deletions
diff --git a/src/components/transport_manager/src/transport_adapter/transport_adapter_listener_impl.cc b/src/components/transport_manager/src/transport_adapter/transport_adapter_listener_impl.cc
index f73748de52..2ab19ade86 100644
--- a/src/components/transport_manager/src/transport_adapter/transport_adapter_listener_impl.cc
+++ b/src/components/transport_manager/src/transport_adapter/transport_adapter_listener_impl.cc
@@ -42,236 +42,334 @@ namespace transport_manager {
 CREATE_LOGGERPTR_GLOBAL(logger_, "TransportManager")
 
 TransportAdapterListenerImpl::TransportAdapterListenerImpl(
-  TransportManagerImpl* manager, TransportAdapter* adapter) :
-  transport_manager_impl_(manager), transport_adapter_(adapter) {
-}
+    TransportManager* manager, TransportAdapter* adapter)
+    : transport_manager_(manager), transport_adapter_(adapter) {}
 
 void TransportAdapterListenerImpl::OnSearchDeviceDone(
-  const TransportAdapter* adapter) {
+    const TransportAdapter* adapter) {
   LOG4CXX_TRACE(logger_, "enter. adapter* " << adapter);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_DONE,
-    transport_adapter_, "", 0, ::protocol_handler::RawMessagePtr(), BaseErrorPtr());
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_DONE,
+      transport_adapter_,
+      "",
+      0,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr());
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnSearchDeviceFailed(
-  const TransportAdapter* adapter, const SearchDeviceError& error) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", error: " << &error);
+    const TransportAdapter* adapter, const SearchDeviceError& error) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", error: " << &error);
   SearchDeviceError* err = new SearchDeviceError(error);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_FAIL,
-    transport_adapter_, "", 0, ::protocol_handler::RawMessagePtr(), BaseErrorPtr(err));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_FAIL,
+      transport_adapter_,
+      "",
+      0,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(err));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDeviceListUpdated(
-  const TransportAdapter* adapter) {
+    const TransportAdapter* adapter) {
   LOG4CXX_TRACE(logger_, "enter. adapter* " << adapter);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_DEVICE_LIST_UPDATED,
-    transport_adapter_, "", 0, ::protocol_handler::RawMessagePtr(), BaseErrorPtr());
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DEVICE_LIST_UPDATED,
+      transport_adapter_,
+      "",
+      0,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr());
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnFindNewApplicationsRequest(
-  const TransportAdapter* adapter) {
+    const TransportAdapter* adapter) {
   LOG4CXX_TRACE(logger_, "enter. adapter* " << adapter);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::ON_FIND_NEW_APPLICATIONS_REQUEST,
-    transport_adapter_, "", 0, ::protocol_handler::RawMessagePtr(), BaseErrorPtr());
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::ON_FIND_NEW_APPLICATIONS_REQUEST,
+      transport_adapter_,
+      "",
+      0,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr());
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnConnectDone(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& application_id) {
-  LOG4CXX_TRACE(logger_, "enter adapter*: " << adapter << ", device: " << &device <<
-                ", application_id: " << &application_id);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& application_id) {
+  LOG4CXX_TRACE(logger_,
+                "enter adapter*: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &application_id);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_DONE,
-    transport_adapter_, device, application_id, ::protocol_handler::RawMessagePtr(),
-    BaseErrorPtr(new BaseError()));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_DONE,
+      transport_adapter_,
+      device,
+      application_id,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(new BaseError()));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnConnectFailed(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id, const ConnectError& error) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id << ", error: " << &error);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id,
+    const ConnectError& error) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id
+                                   << ", error: " << &error);
   ConnectError* err = new ConnectError(error);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_FAIL,
-    transport_adapter_, device, app_id, ::protocol_handler::RawMessagePtr(), BaseErrorPtr(err));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_FAIL,
+      transport_adapter_,
+      device,
+      app_id,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(err));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDisconnectDone(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_DONE,
-    transport_adapter_, device, app_id, ::protocol_handler::RawMessagePtr(),
-    BaseErrorPtr(new BaseError()));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_DONE,
+      transport_adapter_,
+      device,
+      app_id,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(new BaseError()));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDisconnectFailed(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id, const DisconnectError& error) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id << ", error: " << &error);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id,
+    const DisconnectError& error) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id
+                                   << ", error: " << &error);
   DisconnectError* err = new DisconnectError(error);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_FAIL,
-    transport_adapter_, device, app_id, ::protocol_handler::RawMessagePtr(), BaseErrorPtr(err));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_FAIL,
+      transport_adapter_,
+      device,
+      app_id,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(err));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDisconnectDeviceDone(
-  const TransportAdapter* adapter, const DeviceUID& device) {
-}
+    const TransportAdapter* adapter, const DeviceUID& device) {}
 
 void TransportAdapterListenerImpl::OnDisconnectDeviceFailed(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const DisconnectDeviceError& error) {
-}
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const DisconnectDeviceError& error) {}
 
 void TransportAdapterListenerImpl::OnDataReceiveDone(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id, const ::protocol_handler::RawMessagePtr data_container) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id << ", data_container: " << data_container);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id,
+    const ::protocol_handler::RawMessagePtr data_container) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id
+                                   << ", data_container: " << data_container);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_DONE,
-    transport_adapter_, device, app_id, data_container,
-    BaseErrorPtr(new BaseError()));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_DONE,
+      transport_adapter_,
+      device,
+      app_id,
+      data_container,
+      BaseErrorPtr(new BaseError()));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDataReceiveFailed(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id, const DataReceiveError& error) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id << ", error: " << &error);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id,
+    const DataReceiveError& error) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id
+                                   << ", error: " << &error);
   DataReceiveError* err = new DataReceiveError(error);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_FAIL,
-    transport_adapter_, device, app_id, ::protocol_handler::RawMessagePtr(), BaseErrorPtr(err));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_FAIL,
+      transport_adapter_,
+      device,
+      app_id,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(err));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDataSendDone(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id, const ::protocol_handler::RawMessagePtr data_container) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id << ", data_container: " << data_container);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id,
+    const ::protocol_handler::RawMessagePtr data_container) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id
+                                   << ", data_container: " << data_container);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_DONE,
-    transport_adapter_, device, app_id, data_container,
-    new BaseError());
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_DONE,
+      transport_adapter_,
+      device,
+      app_id,
+      data_container,
+      new BaseError());
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnDataSendFailed(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id, const ::protocol_handler::RawMessagePtr data_container,
-  const DataSendError& error) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id << ", data_container: " << data_container << ", error: "
-                << &error);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id,
+    const ::protocol_handler::RawMessagePtr data_container,
+    const DataSendError& error) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id
+                                   << ", data_container: " << data_container
+                                   << ", error: " << &error);
   DataSendError* err = new DataSendError(error);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_FAIL,
-    transport_adapter_, device, app_id, data_container, BaseErrorPtr(err));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_FAIL,
+      transport_adapter_,
+      device,
+      app_id,
+      data_container,
+      BaseErrorPtr(err));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnConnectRequested(
-  const TransportAdapter* adapter, const DeviceUID& device_handle,
-  const ApplicationHandle& app_handle) {
-}
+    const TransportAdapter* adapter,
+    const DeviceUID& device_handle,
+    const ApplicationHandle& app_handle) {}
 
 void TransportAdapterListenerImpl::OnUnexpectedDisconnect(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& application, const CommunicationError& error) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application: " << &application << ", error: " << &error);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& application,
+    const CommunicationError& error) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application: " << &application
+                                   << ", error: " << &error);
   CommunicationError* err = new CommunicationError(error);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_UNEXPECTED_DISCONNECT,
-    transport_adapter_, device, application, ::protocol_handler::RawMessagePtr(), BaseErrorPtr(err));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_UNEXPECTED_DISCONNECT,
+      transport_adapter_,
+      device,
+      application,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(err));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
 
 void TransportAdapterListenerImpl::OnCommunicationError(
-  const TransportAdapter* adapter, const DeviceUID& device,
-  const ApplicationHandle& app_id) {
-  LOG4CXX_TRACE(logger_, "enter. adapter: " << adapter << ", device: " << &device <<
-                ", application_id: " << &app_id);
+    const TransportAdapter* adapter,
+    const DeviceUID& device,
+    const ApplicationHandle& app_id) {
+  LOG4CXX_TRACE(logger_,
+                "enter. adapter: " << adapter << ", device: " << &device
+                                   << ", application_id: " << &app_id);
   const TransportAdapterEvent event(
-    TransportAdapterListenerImpl::EventTypeEnum::ON_COMMUNICATION_ERROR,
-    transport_adapter_, device, app_id, ::protocol_handler::RawMessagePtr(),
-    BaseErrorPtr(new BaseError()));
-  if (transport_manager::E_SUCCESS
-      != transport_manager_impl_->ReceiveEventFromDevice(event)) {
+      TransportAdapterListenerImpl::EventTypeEnum::ON_COMMUNICATION_ERROR,
+      transport_adapter_,
+      device,
+      app_id,
+      ::protocol_handler::RawMessagePtr(),
+      BaseErrorPtr(new BaseError()));
+  if (transport_manager_ != NULL &&
+      transport_manager::E_SUCCESS !=
+          transport_manager_->ReceiveEventFromDevice(event)) {
     LOG4CXX_WARN(logger_, "Failed to receive event from device");
   }
   LOG4CXX_TRACE(logger_, "exit");
 }
-} // namespace transport_manager
+}  // namespace transport_manager