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 "cafragmentation.h"
33 #include "caqueueingthread.h"
34 #include "oic_malloc.h"
35 #include "caremotehandler.h"
39 * @var EDR_ADAPTER_TAG
40 * @brief Logging tag for module name.
42 #define EDR_ADAPTER_TAG "OIC_CA_EDR_ADAP"
45 * @var g_edrThreadPool
46 * @brief Reference to threadpool.
48 static ca_thread_pool_t g_edrThreadPool = NULL;
51 * @var g_sendQueueHandle
52 * @brief Queue handle for Send Data
54 static CAQueueingThread_t *g_sendQueueHandle = NULL;
57 * @var g_recvQueueHandle
58 * @brief Queue handle for Receive Data
60 static CAQueueingThread_t *g_recvQueueHandle = NULL;
64 * @brief Storing Adapter state information
66 static bool g_adapterState = true;
69 * @var g_networkPacketReceivedCallback
70 * @brief Maintains the callback to be notified on receival of network packets from other
73 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
76 * @var g_networkChangeCallback
77 * @brief Maintains the callback to be notified on local bluetooth adapter status change.
79 static CANetworkChangeCallback g_networkChangeCallback = NULL;
82 * @var g_errorCallback
83 * @brief error Callback to CA adapter
85 static CAErrorHandleCallback g_errorCallback = NULL;
88 * @var g_localConnectivity
89 * @brief Information of local Bluetooth adapter.
91 static CAEndpoint_t *g_localConnectivity = NULL;
95 * @brief Storing Rfcommserver state information
97 static bool g_serverState = false;
99 static CAResult_t CAStartServer();
100 static CAResult_t CAEDRInitializeQueueHandlers();
101 CAResult_t CAEDRInitializeSendHandler();
102 CAResult_t CAEDRInitializeReceiveHandler();
103 void CAAdapterTerminateQueues();
104 void CAAdapterDataSendHandler(void *context);
105 void CAAdapterDataReceiverHandler(void *context);
106 CAResult_t CAAdapterStopQueue();
107 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
108 uint32_t *sentLength);
109 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status);
110 void CAEDROnNetworkStatusChanged(void *context);
111 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID,
112 const uint8_t *data, uint32_t dataLength, uint32_t *sentLength);
113 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity, CANetworkStatus_t status);
114 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
115 uint32_t dataLength);
118 * @fn CACreateEDRData
119 * @brief Helper function to create CAEDRData
121 static CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, const uint8_t *data,
122 uint32_t dataLength);
126 * @brief Free the Created EDR data
128 static void CAFreeEDRData(CAEDRData *edrData);
131 * @fn CAEDRFreeNetworkEvent
132 * @brief Free the memory associated with @event.
134 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event);
136 static void CAEDRDataDestroyer(void *data, uint32_t size);
138 static void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
139 uint32_t dataLength, CAResult_t result);
141 CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
142 CANetworkPacketReceivedCallback packetReceivedCallback,
143 CANetworkChangeCallback networkStateChangeCallback,
144 CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
147 VERIFY_NON_NULL(registerCallback, EDR_ADAPTER_TAG, "register callback is NULL");
148 VERIFY_NON_NULL(packetReceivedCallback, EDR_ADAPTER_TAG, "data receive callback is NULL");
149 VERIFY_NON_NULL(networkStateChangeCallback, EDR_ADAPTER_TAG,
150 "network state change callback is NULL");
151 VERIFY_NON_NULL(handle, EDR_ADAPTER_TAG, "Thread pool handle is NULL");
153 // Register the callbacks
155 g_edrThreadPool = handle;
156 g_networkPacketReceivedCallback = packetReceivedCallback;
157 g_networkChangeCallback = networkStateChangeCallback;
158 g_errorCallback = errorCallback;
160 // Initialize EDR Network Monitor
161 CAResult_t res = CAEDRInitializeNetworkMonitor(handle);
162 if (CA_STATUS_OK != res)
164 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR N/w Monitor Initialize failed!, error number [%d]",
169 CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus);
170 CAEDRSetPacketReceivedCallback(CAAdapterRecvData);
171 CAEDRSetErrorHandler(CAEDRErrorHandler);
172 res = CAEDRClientInitialize();
173 if (CA_STATUS_OK != res)
175 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Client Initialize failed, error number [%d]", res);
179 res = CAEDRServerInitialize(handle);
180 if (CA_STATUS_OK != res)
182 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Server Initialize failed, error number [%d]", res);
186 static const CAConnectivityHandler_t handler =
188 .startAdapter = CAStartEDR,
189 .stopAdapter = CAStopEDR,
190 .startListenServer = CAStartEDRListeningServer,
191 .stopListenServer = CAStopEDRListeningServer,
192 .startDiscoveryServer = CAStartEDRDiscoveryServer,
193 .sendData = CASendEDRUnicastData,
194 .sendDataToAll = CASendEDRMulticastData,
195 .GetnetInfo = CAGetEDRInterfaceInformation,
196 .readData = CAReadEDRData,
197 .terminate = CATerminateEDR,
198 .cType = CA_ADAPTER_RFCOMM_BTEDR
200 registerCallback(handler);
202 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
206 CAResult_t CAStartEDR()
208 //Start Monitoring EDR Network
209 CAResult_t ret = CAEDRStartNetworkMonitor();
210 if (CA_STATUS_OK != ret)
212 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start n/w monitor");
215 // Get Bluetooth adapter state
216 bool adapterState = false;
217 if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
219 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
220 return CA_STATUS_FAILED;
223 if (false == adapterState)
225 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
226 g_adapterState = false;
227 return CA_ADAPTER_NOT_ENABLED;
230 if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks()))
232 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Start Network Monitor failed!, error number [%d] ",
236 // Initialize Send/Receive data message queues
237 if (CA_STATUS_OK != (ret = CAEDRInitializeQueueHandlers()))
239 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
240 "CAAdapterInitializeQueues failed!, error number [%d] ", ret);
242 return CA_STATUS_FAILED;
245 // Start Send/Receive data message queues
246 if (CA_STATUS_OK != (ret = CAAdapterStartQueue()))
248 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAAdapterStartQueue failed!, error number [%d] ", ret);
254 CAResult_t CAStartEDRListeningServer()
256 return CAStartServer();
259 CAResult_t CAStopEDRListeningServer()
261 return CAEDRServerStop();
264 CAResult_t CAStartEDRDiscoveryServer()
266 return CAStartServer();
269 int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
273 VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
274 VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
278 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
282 if (0 == strlen(remoteEndpoint->addr))
284 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
288 uint32_t sentLength = 0;
289 const char *serviceUUID = OIC_EDR_SERVICE_ID;
290 const char *address = remoteEndpoint->addr;
291 CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
292 if (CA_STATUS_OK != err)
294 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
295 g_errorCallback(remoteEndpoint, data, dataLength, err);
302 int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
304 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
307 VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
311 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
315 uint32_t sentLen = 0;
316 const char *serviceUUID = OIC_EDR_SERVICE_ID;
317 CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
318 if (CA_STATUS_OK != err)
320 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
321 g_errorCallback(endpoint, data, dataLength, err);
325 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
329 CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
331 VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
333 CAResult_t err = CA_STATUS_OK;
335 if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
337 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
338 "Failed to get local interface information!, error num [%d]", err);
346 CAResult_t CAReadEDRData()
348 return CAEDRManagerReadData();
351 CAResult_t CAStopEDR()
353 // Stop RFComm server if it is running
356 // Stop network monitor
357 CAEDRStopNetworkMonitor();
360 CAEDRClientUnsetCallbacks();
362 // Disconnect all the client connections
363 CAEDRClientDisconnectAll();
365 // Stop Send and receive Queue
366 CAAdapterStopQueue();
371 void CATerminateEDR()
373 // Terminate EDR Network Monitor
374 CAEDRTerminateNetworkMonitor();
376 // Terminate Send/Receive data messages queues
377 CAAdapterTerminateQueues();
379 g_networkPacketReceivedCallback = NULL;
380 g_networkChangeCallback = NULL;
382 // Terminate thread pool
383 g_edrThreadPool = NULL;
385 // Terminate EDR Client
386 CAEDRClientTerminate();
388 // Terminate EDR Server
389 CAEDRServerTerminate();
391 // Free LocalConnectivity information
392 CAFreeEndpoint(g_localConnectivity);
393 g_localConnectivity = NULL;
396 CAResult_t CAStartServer()
398 if (false == g_adapterState)
400 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
401 // Setting g_serverState for starting Rfcommserver when adapter starts
402 g_serverState = true;
406 CAResult_t err = CA_STATUS_OK;
407 if (CA_STATUS_OK != (err = CAEDRServerStart()))
409 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
417 CAResult_t CAEDRInitializeQueueHandlers()
419 if (CA_STATUS_OK == CAEDRInitializeSendHandler()
420 && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
422 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
426 return CA_STATUS_FAILED;
429 CAResult_t CAEDRInitializeSendHandler()
431 // Check if the message queue is already initialized
432 if (g_sendQueueHandle)
434 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
438 g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
439 if (!g_sendQueueHandle)
441 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
442 return CA_MEMORY_ALLOC_FAILED;
445 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
446 CAAdapterDataSendHandler, CAEDRDataDestroyer))
448 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
449 return CA_STATUS_FAILED;
454 CAResult_t CAEDRInitializeReceiveHandler()
456 // Check if the message queue is already initialized
457 if (g_recvQueueHandle)
459 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
463 g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
464 if (!g_recvQueueHandle)
466 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
467 return CA_MEMORY_ALLOC_FAILED;
471 if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
472 CAAdapterDataReceiverHandler,
475 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
476 OICFree(g_recvQueueHandle);
477 g_recvQueueHandle = NULL;
478 return CA_STATUS_FAILED;
484 void CAAdapterTerminateQueues()
486 if (g_sendQueueHandle)
488 CAQueueingThreadDestroy(g_sendQueueHandle);
489 g_sendQueueHandle = NULL;
491 if (g_recvQueueHandle)
493 CAQueueingThreadDestroy(g_recvQueueHandle);
494 g_recvQueueHandle = NULL;
498 void CAAdapterDataSendHandler(void *context)
500 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
502 CAEDRData *message = (CAEDRData *) context;
505 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
509 if (!message->remoteEndpoint)
511 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
515 const char *remoteAddress = message->remoteEndpoint->addr;
518 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
519 //Error cannot be sent if remote address is NULL
523 CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
524 if(CA_STATUS_OK != result)
526 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
527 CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
531 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
534 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
537 CAResult_t result = CA_SEND_FAILED;
539 // Send the first segment with the header.
540 if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
542 result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
543 if (CA_STATUS_OK != result)
545 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
551 OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
552 result = CAEDRClientSendMulticastData(data, dataLength);
554 if (CA_STATUS_OK != result)
556 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
563 void CAAdapterDataReceiverHandler(void *context)
565 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
567 if (NULL == g_networkPacketReceivedCallback)
569 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "g_networkPacketReceivedCallback is NULL");
573 CAEDRData *message = (CAEDRData *) context;
574 if (NULL == message || NULL == message->remoteEndpoint)
576 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
580 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
581 CA_ADAPTER_RFCOMM_BTEDR,
582 message->remoteEndpoint->addr,
585 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
587 const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint };
589 g_networkPacketReceivedCallback(&sep, message->data, message->dataLen);
591 CAFreeEndpoint(remoteEndpoint);
593 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
596 CAResult_t CAAdapterStartQueue()
598 // Start send queue thread
599 if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
601 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
602 CAEDRClientUnsetCallbacks();
603 //Disconnect all the client connections
604 CAEDRClientDisconnectAll();
605 return CA_STATUS_FAILED;
608 // Start receive queue thread
609 if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
611 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
612 CAEDRClientUnsetCallbacks();
613 //Disconnect all the client connections
614 CAEDRClientDisconnectAll();
615 return CA_STATUS_FAILED;
621 CAResult_t CAAdapterStopQueue()
623 //Stop send queue thread
624 CAQueueingThreadStop(g_sendQueueHandle);
626 //Stop receive queue thread
627 CAQueueingThreadStop(g_recvQueueHandle);
632 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
633 uint32_t *sentLength)
635 if (false == g_adapterState)
637 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
643 VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
644 VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
646 // Create remote endpoint
647 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
648 CA_ADAPTER_RFCOMM_BTEDR,
650 if (NULL == remoteEndpoint)
652 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
656 // Add message to data queue
657 CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
658 CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
659 *sentLength = dataLength;
661 // Free remote endpoint
662 CAFreeEndpoint(remoteEndpoint);
665 void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
666 uint32_t dataLength, CAResult_t result)
669 VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
671 // Create remote endpoint
672 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
676 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
680 g_errorCallback(remoteEndpoint, data, dataLength, result);
682 // Free remote endpoint
683 CAFreeEndpoint(remoteEndpoint);
686 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
687 uint32_t dataLength, uint32_t *sentLength)
689 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
691 if (false == g_adapterState)
693 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
695 return CA_ADAPTER_NOT_ENABLED;
698 VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
699 VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
700 VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
702 // Create remote endpoint
703 CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
704 CA_ADAPTER_RFCOMM_BTEDR,
706 if (NULL == remoteEndpoint)
708 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
709 return CA_MEMORY_ALLOC_FAILED;
712 // Add message to data queue
713 CAEDRData *edrData = CACreateEDRData(remoteEndpoint, data, dataLength);
714 CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
715 *sentLength = dataLength;
717 // Free remote endpoint
718 CAFreeEndpoint(remoteEndpoint);
720 OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
724 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
726 // Create localconnectivity
727 if (NULL == g_localConnectivity)
729 CAEDRGetInterfaceInformation(&g_localConnectivity);
732 if (CA_INTERFACE_UP == status)
734 if (false == g_adapterState)
736 // Get Bluetooth adapter state
737 bool adapterState = false;
738 if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
740 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
744 if (false == adapterState)
746 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
747 g_adapterState = false;
750 CAEDRClientSetCallbacks();
751 g_adapterState = true;
752 CAAdapterStartQueue();
753 // starting RFCommServer
754 if (true == g_serverState)
757 g_serverState = false;
763 g_adapterState = false;
766 // Notify to upper layer
767 if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
769 // Add notification task to thread pool
770 CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
773 if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
774 CAEDROnNetworkStatusChanged,event))
776 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
783 void CAEDROnNetworkStatusChanged(void *context)
787 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
791 CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
793 // Notify to upper layer
794 if (g_networkChangeCallback)
796 g_networkChangeCallback(networkEvent->info, networkEvent->status);
799 // Free the created Network event
800 CAEDRFreeNetworkEvent(networkEvent);
803 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
804 CANetworkStatus_t status)
806 VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
808 // Create CAEDRNetworkEvent
809 CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
812 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
816 // Create duplicate of Local connectivity
817 event->info = CACloneEndpoint(connectivity);
818 event->status = status;
822 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
826 CAFreeEndpoint(event->info);
831 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
832 const uint8_t *data, uint32_t dataLength)
834 CAEDRData *edrData = (CAEDRData *) OICCalloc(1, sizeof(*edrData));
837 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
841 edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
843 edrData->data = OICMalloc(dataLength);
844 if (NULL == edrData->data)
846 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
847 CAFreeEDRData(edrData);
850 memcpy(edrData->data, data, dataLength);
851 edrData->dataLen = dataLength;
856 void CAFreeEDRData(CAEDRData *edrData)
858 VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
860 CAFreeEndpoint(edrData->remoteEndpoint);
861 OICFree(edrData->data);
865 void CAEDRDataDestroyer(void *data, uint32_t size)
867 if ((size_t)size < sizeof(CAEDRData))
869 OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d", data, size);
871 CAEDRData *edrdata = (CAEDRData *) data;
873 CAFreeEDRData(edrdata);