2 * \file transport_adapter_listener_impl.cc
3 * \brief TransportAdapterListenerImpl class source file.
5 * Copyright (c) 2013, Ford Motor Company
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * Redistributions of source code must retain the above copyright notice, this
12 * list of conditions and the following disclaimer.
14 * Redistributions in binary form must reproduce the above copyright notice,
15 * this list of conditions and the following
16 * disclaimer in the documentation and/or other materials provided with the
19 * Neither the name of the Ford Motor Company nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
38 #include "utils/logger.h"
40 #include "transport_manager/transport_adapter/transport_adapter_listener_impl.h"
41 #include "transport_manager/transport_manager_impl.h"
42 #include "transport_manager/transport_adapter/transport_adapter_event.h"
44 namespace transport_manager {
46 CREATE_LOGGERPTR_GLOBAL(logger_, "TransportAdapterImpl")
48 TransportAdapterListenerImpl::~TransportAdapterListenerImpl() {}
50 TransportAdapterListenerImpl::TransportAdapterListenerImpl(
51 TransportManagerImpl* manager, TransportAdapter* adapter)
52 : transport_manager_impl_(manager), transport_adapter_(adapter) {}
54 void TransportAdapterListenerImpl::OnSearchDeviceDone(
55 const TransportAdapter* adapter) {
56 TransportAdapterEvent event(
57 TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_DONE,
58 transport_adapter_, "", 0, RawMessageSptr(), new BaseError());
60 if (transport_manager::E_SUCCESS !=
61 transport_manager_impl_->ReceiveEventFromDevice(event)) {
62 LOG4CXX_WARN(logger_, "Failed to receive event from device");
66 void TransportAdapterListenerImpl::OnSearchDeviceFailed(
67 const TransportAdapter* adapter,
68 const SearchDeviceError& error) {
69 SearchDeviceError* err = new SearchDeviceError(error);
70 TransportAdapterEvent event(
71 TransportAdapterListenerImpl::EventTypeEnum::ON_SEARCH_FAIL,
72 transport_adapter_, "", 0, RawMessageSptr(), err);
74 if (transport_manager::E_SUCCESS !=
75 transport_manager_impl_->ReceiveEventFromDevice(event)) {
76 LOG4CXX_WARN(logger_, "Failed to receive event from device");
80 void TransportAdapterListenerImpl::OnDeviceListUpdated(
81 const TransportAdapter* adapter) {
82 TransportAdapterEvent event(
83 TransportAdapterListenerImpl::EventTypeEnum::ON_DEVICE_LIST_UPDATED,
84 transport_adapter_, "", 0, RawMessageSptr(), NULL);
86 if (transport_manager::E_SUCCESS !=
87 transport_manager_impl_->ReceiveEventFromDevice(event)) {
88 LOG4CXX_WARN(logger_, "Failed to receive event from device");
92 void TransportAdapterListenerImpl::OnApplicationListUpdated(const TransportAdapter* adapter,
93 const DeviceUID& device_handle) {
94 TransportAdapterEvent event(TransportAdapterListenerImpl::EventTypeEnum::ON_APPLICATION_LIST_UPDATED,
95 transport_adapter_, device_handle, 0, RawMessageSptr(), NULL);
97 if (transport_manager::E_SUCCESS !=
98 transport_manager_impl_->ReceiveEventFromDevice(event)) {
99 LOG4CXX_WARN(logger_, "Failed to receive event from device");
103 void TransportAdapterListenerImpl::OnConnectDone(
104 const TransportAdapter* adapter, const DeviceUID& device,
105 const ApplicationHandle& application_id) {
106 TransportAdapterEvent event(
107 TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_DONE,
108 transport_adapter_, device, application_id, RawMessageSptr(),
111 if (transport_manager::E_SUCCESS !=
112 transport_manager_impl_->ReceiveEventFromDevice(event)) {
113 LOG4CXX_WARN(logger_, "Failed to receive event from device");
117 void TransportAdapterListenerImpl::OnConnectFailed(
118 const TransportAdapter* adapter, const DeviceUID& device,
119 const ApplicationHandle& app_id, const ConnectError& error) {
120 ConnectError* err = new ConnectError(error);
121 TransportAdapterEvent event(
122 TransportAdapterListenerImpl::EventTypeEnum::ON_CONNECT_FAIL,
123 transport_adapter_, device, app_id, RawMessageSptr(), err);
125 if (transport_manager::E_SUCCESS !=
126 transport_manager_impl_->ReceiveEventFromDevice(event)) {
127 LOG4CXX_WARN(logger_, "Failed to receive event from device");
131 void TransportAdapterListenerImpl::OnDisconnectDone(
132 const TransportAdapter* adapter, const DeviceUID& device,
133 const ApplicationHandle& app_id) {
134 TransportAdapterEvent event(
135 TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_DONE,
136 transport_adapter_, device, app_id, RawMessageSptr(), new BaseError());
138 if (transport_manager::E_SUCCESS !=
139 transport_manager_impl_->ReceiveEventFromDevice(event)) {
140 LOG4CXX_WARN(logger_, "Failed to receive event from device");
144 void TransportAdapterListenerImpl::OnDisconnectFailed(
145 const TransportAdapter* adapter, const DeviceUID& device,
146 const ApplicationHandle& app_id, const DisconnectError& error) {
147 DisconnectError* err = new DisconnectError(error);
148 TransportAdapterEvent event(
149 TransportAdapterListenerImpl::EventTypeEnum::ON_DISCONNECT_FAIL,
150 transport_adapter_, device, app_id, RawMessageSptr(), err);
152 if (transport_manager::E_SUCCESS !=
153 transport_manager_impl_->ReceiveEventFromDevice(event)) {
154 LOG4CXX_WARN(logger_, "Failed to receive event from device");
158 void TransportAdapterListenerImpl::OnDisconnectDeviceDone(
159 const TransportAdapter* adapter, const DeviceUID& device) {}
161 void TransportAdapterListenerImpl::OnDisconnectDeviceFailed(
162 const TransportAdapter* adapter, const DeviceUID& device,
163 const DisconnectDeviceError& error) {}
165 void TransportAdapterListenerImpl::OnDataReceiveDone(
166 const TransportAdapter* adapter, const DeviceUID& device,
167 const ApplicationHandle& app_id, const RawMessageSptr data_container) {
168 TransportAdapterEvent event(
169 TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_DONE,
170 transport_adapter_, device, app_id, data_container, new BaseError());
172 if (transport_manager::E_SUCCESS !=
173 transport_manager_impl_->ReceiveEventFromDevice(event)) {
174 LOG4CXX_WARN(logger_, "Failed to receive event from device");
178 void TransportAdapterListenerImpl::OnDataReceiveFailed(
179 const TransportAdapter* adapter, const DeviceUID& device,
180 const ApplicationHandle& app_id, const DataReceiveError& error) {
181 DataReceiveError* err = new DataReceiveError(error);
182 TransportAdapterEvent event(
183 TransportAdapterListenerImpl::EventTypeEnum::ON_RECEIVED_FAIL,
184 transport_adapter_, device, app_id, RawMessageSptr(), err);
186 if (transport_manager::E_SUCCESS !=
187 transport_manager_impl_->ReceiveEventFromDevice(event)) {
188 LOG4CXX_WARN(logger_, "Failed to receive event from device");
192 void TransportAdapterListenerImpl::OnDataSendDone(
193 const TransportAdapter* adapter, const DeviceUID& device,
194 const ApplicationHandle& app_id, const RawMessageSptr data_container) {
195 TransportAdapterEvent event(
196 TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_DONE,
197 transport_adapter_, device, app_id, data_container, new BaseError());
199 if (transport_manager::E_SUCCESS !=
200 transport_manager_impl_->ReceiveEventFromDevice(event)) {
201 LOG4CXX_WARN(logger_, "Failed to receive event from device");
205 void TransportAdapterListenerImpl::OnDataSendFailed(
206 const TransportAdapter* adapter, const DeviceUID& device,
207 const ApplicationHandle& app_id, const RawMessageSptr data_container,
208 const DataSendError& error) {
209 DataSendError* err = new DataSendError(error);
210 TransportAdapterEvent event(
211 TransportAdapterListenerImpl::EventTypeEnum::ON_SEND_FAIL,
212 transport_adapter_, device, app_id, data_container, err);
214 if (transport_manager::E_SUCCESS !=
215 transport_manager_impl_->ReceiveEventFromDevice(event)) {
216 LOG4CXX_WARN(logger_, "Failed to receive event from device");
220 void TransportAdapterListenerImpl::OnConnectRequested(
221 const TransportAdapter* adapter, const DeviceUID& device_handle,
222 const ApplicationHandle& app_handle) {}
224 void TransportAdapterListenerImpl::OnUnexpectedDisconnect(
225 const TransportAdapter* adapter,
226 const DeviceUID& device, const ApplicationHandle& application,
227 const CommunicationError& error) {
228 CommunicationError* err = new CommunicationError(error);
229 TransportAdapterEvent event(
230 TransportAdapterListenerImpl::EventTypeEnum::ON_UNEXPECTED_DISCONNECT,
231 transport_adapter_, device, application, RawMessageSptr(), err);
233 if (transport_manager::E_SUCCESS !=
234 transport_manager_impl_->ReceiveEventFromDevice(event)) {
235 LOG4CXX_WARN(logger_, "Failed to receive event from device");
239 void TransportAdapterListenerImpl::OnCommunicationError(
240 const TransportAdapter* adapter, const DeviceUID& device,
241 const ApplicationHandle& app_id) {
242 TransportAdapterEvent event(
243 TransportAdapterListenerImpl::EventTypeEnum::ON_COMMUNICATION_ERROR,
244 transport_adapter_, device, app_id, RawMessageSptr(), new BaseError());
246 if (transport_manager::E_SUCCESS !=
247 transport_manager_impl_->ReceiveEventFromDevice(event)) {
248 LOG4CXX_WARN(logger_, "Failed to receive event from device");
252 } // namespace transport_manager