1 /******************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 ******************************************************************/
24 * This file contains the APIs for EDR adapter.
27 #include "caedradapter.h"
29 #include "caedrinterface.h"
30 #include "caadapterutils.h"
32 #include "caqueueingthread.h"
33 #include "oic_malloc.h"
34 #include "caremotehandler.h"
38 * @var EDR_ADAPTER_TAG
39 * @brief Logging tag for module name.
41 #define EDR_ADAPTER_TAG "OIC_CA_EDR_ADAP"
44 * @var g_edrThreadPool
45 * @brief Reference to threadpool.
47 static ca_thread_pool_t g_edrThreadPool = NULL;
50 * @var g_sendQueueHandle
51 * @brief Queue handle for Send Data
53 static CAQueueingThread_t *g_sendQueueHandle = NULL;
56 * @var g_recvQueueHandle
57 * @brief Queue handle for Receive Data
59 static CAQueueingThread_t *g_recvQueueHandle = NULL;
63 * @brief Storing Adapter state information
65 static bool g_adapterState = true;
68 * @var g_networkPacketReceivedCallback
69 * @brief Maintains the callback to be notified on receival of network packets from other
72 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
75 * @var g_networkChangeCallback
76 * @brief Maintains the callback to be notified on local bluetooth adapter status change.
78 static CANetworkChangeCallback g_networkChangeCallback = NULL;
81 * @var g_errorCallback
82 * @brief error Callback to CA adapter
84 static CAErrorHandleCallback g_errorCallback = NULL;
87 * @var g_localConnectivity
88 * @brief Information of local Bluetooth adapter.
90 static CAEndpoint_t *g_localConnectivity = NULL;
94 * @brief Storing Rfcommserver state information
96 static bool g_serverState = false;
98 static CAResult_t CAStartServer();
99 static CAResult_t CAEDRInitializeQueueHandlers();
100 CAResult_t CAEDRInitializeSendHandler();
101 CAResult_t CAEDRInitializeReceiveHandler();
102 void CAAdapterTerminateQueues();
103 void CAAdapterDataSendHandler(void *context);
104 void CAAdapterDataReceiverHandler(void *context);
105 CAResult_t CAAdapterStopQueue();
106 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
107 uint32_t *sentLength);
108 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
109 void CAEDROnNetworkStatusChanged(void *context);
110 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
111 const uint8_t *data, uint32_t dataLength, uint32_t *sentLength);
112 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity, CANetworkStatus_t status);
113 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
114 uint32_t dataLength);
117 * @fn CACreateEDRData
118 * @brief Helper function to create CAEDRData
120 static CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, const uint8_t *data,
121 uint32_t dataLength);
125 * @brief Free the Created EDR data
127 static void CAFreeEDRData(CAEDRData *edrData);
130 * @fn CAEDRFreeNetworkEvent
131 * @brief Free the memory associated with @event.
133 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event);
135 static void CAEDRDataDestroyer(void *data, uint32_t size);
137 static void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
138 uint32_t dataLength, CAResult_t result);
140 CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
141 CANetworkPacketReceivedCallback packetReceivedCallback,
142 CANetworkChangeCallback networkStateChangeCallback,
143 CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
146 VERIFY_NON_NULL(registerCallback, EDR_ADAPTER_TAG, "register callback is NULL");
147 VERIFY_NON_NULL(packetReceivedCallback, EDR_ADAPTER_TAG, "data receive callback is NULL");
148 VERIFY_NON_NULL(networkStateChangeCallback, EDR_ADAPTER_TAG,
149 "network state change callback is NULL");
150 VERIFY_NON_NULL(handle, EDR_ADAPTER_TAG, "Thread pool handle is NULL");
152 // Register the callbacks
154 g_edrThreadPool = handle;
155 g_networkPacketReceivedCallback = packetReceivedCallback;
156 g_networkChangeCallback = networkStateChangeCallback;
157 g_errorCallback = errorCallback;
159 // Initialize EDR Network Monitor
160 CAResult_t res = CAEDRInitializeNetworkMonitor(handle);
161 if (CA_STATUS_OK != res)
163 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR N/w Monitor Initialize failed!, error number [%d]",
168 CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus);
169 CAEDRSetPacketReceivedCallback(CAAdapterRecvData);
170 CAEDRSetErrorHandler(CAEDRErrorHandler);
171 res = CAEDRClientInitialize();
172 if (CA_STATUS_OK != res)
174 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Client Initialize failed, error number [%d]", res);
178 res = CAEDRServerInitialize(handle);
179 if (CA_STATUS_OK != res)
181 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Server Initialize failed, error number [%d]", res);
185 static const CAConnectivityHandler_t handler =
187 .startAdapter = CAStartEDR,
188 .stopAdapter = CAStopEDR,
189 .startListenServer = CAStartEDRListeningServer,
190 .stopListenServer = CAStopEDRListeningServer,
191 .startDiscoveryServer = CAStartEDRDiscoveryServer,
192 .sendData = CASendEDRUnicastData,
193 .sendDataToAll = CASendEDRMulticastData,
194 .GetnetInfo = CAGetEDRInterfaceInformation,
195 .readData = CAReadEDRData,
196 .terminate = CATerminateEDR,
197 .cType = CA_ADAPTER_RFCOMM_BTEDR
199 registerCallback(handler);
201 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
205 CAResult_t CAStartEDR()
207 //Start Monitoring EDR Network
208 CAResult_t ret = CAEDRStartNetworkMonitor();
209 if (CA_STATUS_OK != ret)
211 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start n/w monitor");
214 // Get Bluetooth adapter state
215 bool adapterState = false;
216 if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
218 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
219 return CA_STATUS_FAILED;
222 if (false == adapterState)
224 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
225 g_adapterState = false;
226 return CA_ADAPTER_NOT_ENABLED;
229 if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks()))
231 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Start Network Monitor failed!, error number [%d] ",
235 // Initialize Send/Receive data message queues
236 if (CA_STATUS_OK != (ret = CAEDRInitializeQueueHandlers()))
238 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
239 "CAAdapterInitializeQueues failed!, error number [%d] ", ret);
241 return CA_STATUS_FAILED;
244 // Start Send/Receive data message queues
245 if (CA_STATUS_OK != (ret = CAAdapterStartQueue()))
247 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAAdapterStartQueue failed!, error number [%d] ", ret);
253 CAResult_t CAStartEDRListeningServer()
255 return CAStartServer();
258 CAResult_t CAStopEDRListeningServer()
260 return CAEDRServerStop();
263 CAResult_t CAStartEDRDiscoveryServer()
266 // Start device discovery
267 CAResult_t result = CAEDRStartDeviceDiscovery();
268 if(CA_STATUS_OK != result)
270 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Failed to Start Device discovery");
274 return CAStartServer();
277 int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
281 VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
282 VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
286 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
290 if (0 == strlen(remoteEndpoint->addr))
292 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
296 uint32_t sentLength = 0;
297 const char *serviceUUID = OIC_EDR_SERVICE_ID;
298 const char *address = remoteEndpoint->addr;
299 CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
300 if (CA_STATUS_OK != err)
302 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
303 g_errorCallback(remoteEndpoint, data, dataLength, err);
310 int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
312 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
315 VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
319 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
323 uint32_t sentLen = 0;
324 const char *serviceUUID = OIC_EDR_SERVICE_ID;
325 CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
326 if (CA_STATUS_OK != err)
328 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
329 g_errorCallback(endpoint, data, dataLength, err);
333 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
337 CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
339 VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
341 CAResult_t err = CA_STATUS_OK;
343 if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
345 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
346 "Failed to get local interface information!, error num [%d]", err);
354 CAResult_t CAReadEDRData()
356 return CAEDRManagerReadData();
359 CAResult_t CAStopEDR()
361 // Stop RFComm server if it is running
364 // Stop network monitor
365 CAEDRStopNetworkMonitor();
368 CAEDRClientUnsetCallbacks();
370 // Disconnect all the client connections
371 CAEDRClientDisconnectAll();
373 // Stop Send and receive Queue
374 CAAdapterStopQueue();
379 void CATerminateEDR()
381 // Terminate EDR Network Monitor
382 CAEDRTerminateNetworkMonitor();
384 // Terminate Send/Receive data messages queues
385 CAAdapterTerminateQueues();
387 g_networkPacketReceivedCallback = NULL;
388 g_networkChangeCallback = NULL;
390 // Terminate thread pool
391 g_edrThreadPool = NULL;
393 // Terminate EDR Client
394 CAEDRClientTerminate();
396 // Terminate EDR Server
397 CAEDRServerTerminate();
399 // Free LocalConnectivity information
400 CAFreeEndpoint(g_localConnectivity);
401 g_localConnectivity = NULL;
404 CAResult_t CAStartServer()
406 if (false == g_adapterState)
408 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
409 // Setting g_serverState for starting Rfcommserver when adapter starts
410 g_serverState = true;
414 CAResult_t err = CA_STATUS_OK;
415 if (CA_STATUS_OK != (err = CAEDRServerStart()))
417 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
425 CAResult_t CAEDRInitializeQueueHandlers()
427 if (CA_STATUS_OK == CAEDRInitializeSendHandler()
428 && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
430 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
434 return CA_STATUS_FAILED;
437 CAResult_t CAEDRInitializeSendHandler()
439 // Check if the message queue is already initialized
440 if (g_sendQueueHandle)
442 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
446 g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
447 if (!g_sendQueueHandle)
449 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
450 return CA_MEMORY_ALLOC_FAILED;
453 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
454 CAAdapterDataSendHandler, CAEDRDataDestroyer))
456 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
457 return CA_STATUS_FAILED;
462 CAResult_t CAEDRInitializeReceiveHandler()
464 // Check if the message queue is already initialized
465 if (g_recvQueueHandle)
467 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
471 g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
472 if (!g_recvQueueHandle)
474 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
475 return CA_MEMORY_ALLOC_FAILED;
479 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
480 CAAdapterDataReceiverHandler,
483 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
484 OICFree(g_recvQueueHandle);
485 g_recvQueueHandle = NULL;
486 return CA_STATUS_FAILED;
492 void CAAdapterTerminateQueues()
494 if (g_sendQueueHandle)
496 CAQueueingThreadDestroy(g_sendQueueHandle);
497 g_sendQueueHandle = NULL;
499 if (g_recvQueueHandle)
501 CAQueueingThreadDestroy(g_recvQueueHandle);
502 g_recvQueueHandle = NULL;
506 void CAAdapterDataSendHandler(void *context)
508 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
510 CAEDRData *message = (CAEDRData *) context;
513 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
517 if (!message->remoteEndpoint)
519 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
523 const char *remoteAddress = message->remoteEndpoint->addr;
526 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
527 //Error cannot be sent if remote address is NULL
531 CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
532 if(CA_STATUS_OK != result)
534 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
535 CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
539 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
542 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
545 CAResult_t result = CA_SEND_FAILED;
547 // Send the first segment with the header.
548 if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
550 result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
551 if (CA_STATUS_OK != result)
553 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
559 OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
560 result = CAEDRClientSendMulticastData(data, dataLength);
562 if (CA_STATUS_OK != result)
564 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
571 void CAAdapterDataReceiverHandler(void *context)
573 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
575 if (NULL == g_networkPacketReceivedCallback)
577 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "g_networkPacketReceivedCallback is NULL");
581 CAEDRData *message = (CAEDRData *) context;
582 if (NULL == message || NULL == message->remoteEndpoint)
584 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
588 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
589 CA_ADAPTER_RFCOMM_BTEDR,
590 message->remoteEndpoint->addr,
595 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "remoteEndpoint is NULL");
599 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
601 const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint };
603 g_networkPacketReceivedCallback(&sep, message->data, message->dataLen);
605 CAFreeEndpoint(remoteEndpoint);
607 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
610 CAResult_t CAAdapterStartQueue()
612 // Start send queue thread
613 if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
615 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
616 CAEDRClientUnsetCallbacks();
617 //Disconnect all the client connections
618 CAEDRClientDisconnectAll();
619 return CA_STATUS_FAILED;
622 // Start receive queue thread
623 if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
625 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
626 CAEDRClientUnsetCallbacks();
627 //Disconnect all the client connections
628 CAEDRClientDisconnectAll();
629 return CA_STATUS_FAILED;
635 CAResult_t CAAdapterStopQueue()
637 //Stop send queue thread
638 CAQueueingThreadStop(g_sendQueueHandle);
640 //Stop receive queue thread
641 CAQueueingThreadStop(g_recvQueueHandle);
646 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
647 uint32_t *sentLength)
649 if (false == g_adapterState)
651 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
657 VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
658 VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
660 // Create remote endpoint
661 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
662 CA_ADAPTER_RFCOMM_BTEDR,
664 if (NULL == remoteEndpoint)
666 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
670 // Add message to data queue
671 CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
672 CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
673 *sentLength = dataLength;
675 // Free remote endpoint
676 CAFreeEndpoint(remoteEndpoint);
679 void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
680 uint32_t dataLength, CAResult_t result)
683 VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
685 // Create remote endpoint
686 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
690 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
694 g_errorCallback(remoteEndpoint, data, dataLength, result);
696 // Free remote endpoint
697 CAFreeEndpoint(remoteEndpoint);
700 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
701 uint32_t dataLength, uint32_t *sentLength)
703 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
705 if (false == g_adapterState)
707 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
709 return CA_ADAPTER_NOT_ENABLED;
712 VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
713 VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
714 VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
716 // Create remote endpoint
717 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
718 CA_ADAPTER_RFCOMM_BTEDR,
720 if (NULL == remoteEndpoint)
722 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
723 return CA_MEMORY_ALLOC_FAILED;
726 // Add message to data queue
727 CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
728 CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
729 *sentLength = dataLength;
731 // Free remote endpoint
732 CAFreeEndpoint(remoteEndpoint);
734 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
738 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
740 // Create localconnectivity
741 if (NULL == g_localConnectivity)
743 CAEDRGetInterfaceInformation(&g_localConnectivity);
746 if (CA_INTERFACE_UP == status)
748 if (false == g_adapterState)
750 // Get Bluetooth adapter state
751 bool adapterState = false;
752 if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
754 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
758 if (false == adapterState)
760 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
761 g_adapterState = false;
764 CAEDRClientSetCallbacks();
765 g_adapterState = true;
766 CAAdapterStartQueue();
767 // starting RFCommServer
768 if (true == g_serverState)
771 g_serverState = false;
777 g_adapterState = false;
780 // Notify to upper layer
781 if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
783 // Add notification task to thread pool
784 CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
787 if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
788 CAEDROnNetworkStatusChanged,event))
790 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
797 void CAEDROnNetworkStatusChanged(void *context)
801 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
805 CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
807 // Notify to upper layer
808 if (g_networkChangeCallback)
810 g_networkChangeCallback(networkEvent->info, networkEvent->status);
813 // Free the created Network event
814 CAEDRFreeNetworkEvent(networkEvent);
817 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
818 CANetworkStatus_t status)
820 VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
822 // Create CAEDRNetworkEvent
823 CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
826 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
830 // Create duplicate of Local connectivity
831 event->info = CACloneEndpoint(connectivity);
832 event->status = status;
836 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
840 CAFreeEndpoint(event->info);
845 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
846 const uint8_t *data, uint32_t dataLength)
848 CAEDRData *edrData = (CAEDRData *) OICCalloc(1, sizeof(*edrData));
851 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
855 edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
857 edrData->data = OICMalloc(dataLength);
858 if (NULL == edrData->data)
860 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
861 CAFreeEDRData(edrData);
864 memcpy(edrData->data, data, dataLength);
865 edrData->dataLen = dataLength;
870 void CAFreeEDRData(CAEDRData *edrData)
872 VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
874 CAFreeEndpoint(edrData->remoteEndpoint);
875 OICFree(edrData->data);
879 void CAEDRDataDestroyer(void *data, uint32_t size)
881 if ((size_t)size < sizeof(CAEDRData))
883 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d", data, size);
885 CAEDRData *edrdata = (CAEDRData *) data;
887 CAFreeEDRData(edrdata);