resource/csdk/connectivity/src/bt_edr_adapter/caedradapter.c

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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.
  18  *
  19  ******************************************************************/
  20
  21 /**
  22  * @file
  23  *
  24  * This file contains the APIs for EDR adapter.
  25  */
  26
  27 #include "caedradapter.h"
  28
  29 #include "caedrinterface.h"
  30 #include "caadapterutils.h"
  31 #include "logger.h"
  32 #include "cafragmentation.h"
  33 #include "caqueueingthread.h"
  34 #include "oic_malloc.h"
  35 #include "caremotehandler.h"
  36 #include "pdu.h"
  37
  38 /**
  39  * @var EDR_ADAPTER_TAG
  40  * @brief Logging tag for module name.
  41  */
  42 #define EDR_ADAPTER_TAG "OIC_CA_EDR_ADAP"
  43
  44 /**
  45  * @var g_edrThreadPool
  46  * @brief Reference to threadpool.
  47  */
  48 static ca_thread_pool_t g_edrThreadPool = NULL;
  49
  50 /**
  51  * @var g_sendQueueHandle
  52  * @brief Queue handle for Send Data
  53  */
  54 static CAQueueingThread_t *g_sendQueueHandle = NULL;
  55
  56 /**
  57  * @var g_recvQueueHandle
  58  * @brief Queue handle for Receive Data
  59  */
  60 static CAQueueingThread_t *g_recvQueueHandle = NULL;
  61
  62 /**
  63  * @var g_adapterState
  64  * @brief Storing Adapter state information
  65  */
  66 static bool g_adapterState = true;
  67
  68 /**
  69  * @var g_networkPacketReceivedCallback
  70  * @brief Maintains the callback to be notified on receival of network packets from other
  71  *          Bluetooth devices.
  72  */
  73 static CANetworkPacketReceivedCallback g_networkPacketReceivedCallback = NULL;
  74
  75 /**
  76  * @var g_networkChangeCallback
  77  * @brief Maintains the callback to be notified on local bluetooth adapter status change.
  78  */
  79 static CANetworkChangeCallback g_networkChangeCallback = NULL;
  80
  81 /**
  82  * @var g_errorCallback
  83  * @brief error Callback to CA adapter
  84  */
  85 static CAErrorHandleCallback g_errorCallback = NULL;
  86
  87 /**
  88  * @var g_localConnectivity
  89  * @brief Information of local Bluetooth adapter.
  90  */
  91 static CAEndpoint_t *g_localConnectivity = NULL;
  92
  93 /**
  94  * @var g_serverState
  95  * @brief Storing Rfcommserver state information
  96  */
  97 static bool g_serverState = false;
  98
  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);
 116
 117 /**
 118  * @fn CACreateEDRData
 119  * @brief Helper function to create CAEDRData
 120  */
 121 static CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint, const uint8_t *data,
 122                                   uint32_t dataLength);
 123
 124 /**
 125  * @fn CAFreeEDRData
 126  * @brief Free the Created EDR data
 127  */
 128 static void CAFreeEDRData(CAEDRData *edrData);
 129
 130 /**
 131  * @fn CAEDRFreeNetworkEvent
 132  * @brief Free the memory associated with @event.
 133  */
 134 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event);
 135
 136 static void CAEDRDataDestroyer(void *data, uint32_t size);
 137
 138 static void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
 139                               uint32_t dataLength, CAResult_t result);
 140
 141 CAResult_t CAInitializeEDR(CARegisterConnectivityCallback registerCallback,
 142                            CANetworkPacketReceivedCallback packetReceivedCallback,
 143                            CANetworkChangeCallback networkStateChangeCallback,
 144                            CAErrorHandleCallback errorCallback, ca_thread_pool_t handle)
 145 {
 146     // Input validation
 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");
 152
 153     // Register the callbacks
 154
 155     g_edrThreadPool = handle;
 156     g_networkPacketReceivedCallback = packetReceivedCallback;
 157     g_networkChangeCallback = networkStateChangeCallback;
 158     g_errorCallback = errorCallback;
 159
 160     // Initialize EDR Network Monitor
 161     CAResult_t res = CAEDRInitializeNetworkMonitor(handle);
 162     if (CA_STATUS_OK != res)
 163     {
 164         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR N/w Monitor Initialize failed!, error number [%d]",
 165                   res);
 166         return res;
 167     }
 168
 169     CAEDRSetNetworkChangeCallback(CAEDRNotifyNetworkStatus);
 170     CAEDRSetPacketReceivedCallback(CAAdapterRecvData);
 171     CAEDRSetErrorHandler(CAEDRErrorHandler);
 172     res = CAEDRClientInitialize();
 173     if (CA_STATUS_OK != res)
 174     {
 175         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Client Initialize failed, error number [%d]", res);
 176         return res;
 177     }
 178
 179     res = CAEDRServerInitialize(handle);
 180     if (CA_STATUS_OK != res)
 181     {
 182         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "EDR Server Initialize failed, error number [%d]", res);
 183         return res;
 184     }
 185
 186     static const CAConnectivityHandler_t handler =
 187         {
 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
 199         };
 200     registerCallback(handler);
 201
 202     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 203     return CA_STATUS_OK;
 204 }
 205
 206 CAResult_t CAStartEDR()
 207 {
 208     //Start Monitoring EDR Network
 209     CAResult_t ret = CAEDRStartNetworkMonitor();
 210     if (CA_STATUS_OK != ret)
 211     {
 212        OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start n/w monitor");
 213     }
 214
 215     // Get Bluetooth adapter state
 216     bool adapterState = false;
 217     if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 218     {
 219         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 220         return CA_STATUS_FAILED;
 221     }
 222
 223     if (false == adapterState)
 224     {
 225         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 226         g_adapterState = false;
 227         return CA_ADAPTER_NOT_ENABLED;
 228     }
 229
 230     if (CA_STATUS_OK != (ret = CAEDRClientSetCallbacks()))
 231     {
 232         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Start Network Monitor failed!, error number [%d] ",
 233                   ret);
 234     }
 235
 236     // Initialize Send/Receive data message queues
 237     if (CA_STATUS_OK != (ret = CAEDRInitializeQueueHandlers()))
 238     {
 239         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 240                   "CAAdapterInitializeQueues failed!, error number [%d] ", ret);
 241         CATerminateEDR();
 242         return CA_STATUS_FAILED;
 243     }
 244
 245     // Start Send/Receive data message queues
 246     if (CA_STATUS_OK != (ret = CAAdapterStartQueue()))
 247     {
 248         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "CAAdapterStartQueue failed!, error number [%d] ", ret);
 249     }
 250
 251     return ret;
 252 }
 253
 254 CAResult_t CAStartEDRListeningServer()
 255 {
 256     return CAStartServer();
 257 }
 258
 259 CAResult_t CAStopEDRListeningServer()
 260 {
 261     return CAEDRServerStop();
 262 }
 263
 264 CAResult_t CAStartEDRDiscoveryServer()
 265 {
 266 #ifdef __TIZEN__
 267     // Start device discovery
 268     CAResult_t result = CAEDRStartDeviceDiscovery();
 269     if(CA_STATUS_OK != result)
 270     {
 271         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Failed to Start Device discovery");
 272     }
 273 #endif
 274
 275     return CAStartServer();
 276 }
 277
 278 int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
 279                              uint32_t dataLength)
 280 {
 281     // Input validation
 282     VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
 283     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 284
 285     if (0 == dataLength)
 286     {
 287         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 288         return -1;
 289     }
 290
 291     if (0 == strlen(remoteEndpoint->addr))
 292     {
 293         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
 294         return -1;
 295     }
 296
 297     uint32_t sentLength = 0;
 298     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 299     const char *address = remoteEndpoint->addr;
 300     CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
 301     if (CA_STATUS_OK != err)
 302     {
 303         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
 304         g_errorCallback(remoteEndpoint, data, dataLength, err);
 305         return -1;
 306     }
 307
 308     return sentLength;
 309 }
 310
 311 int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
 312 {
 313     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
 314
 315     // Input validation
 316     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 317
 318     if (0 == dataLength)
 319     {
 320         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 321         return -1;
 322     }
 323
 324     uint32_t sentLen = 0;
 325     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 326     CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
 327     if (CA_STATUS_OK != err)
 328     {
 329         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
 330         g_errorCallback(endpoint, data, dataLength, err);
 331         return -1;
 332     }
 333
 334     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
 335     return sentLen;
 336 }
 337
 338 CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
 339 {
 340     VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
 341
 342     CAResult_t err = CA_STATUS_OK;
 343     *size = 0;
 344     if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
 345     {
 346         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 347                   "Failed to get local interface information!, error num [%d]", err);
 348         return err;
 349     }
 350
 351     *size = 1;
 352     return err;
 353 }
 354
 355 CAResult_t CAReadEDRData()
 356 {
 357     return CAEDRManagerReadData();
 358 }
 359
 360 CAResult_t CAStopEDR()
 361 {
 362     // Stop RFComm server if it is running
 363     CAEDRServerStop();
 364
 365     // Stop network monitor
 366     CAEDRStopNetworkMonitor();
 367
 368     // Stop the adapter
 369     CAEDRClientUnsetCallbacks();
 370
 371     // Disconnect all the client connections
 372     CAEDRClientDisconnectAll();
 373
 374     // Stop Send and receive Queue
 375     CAAdapterStopQueue();
 376
 377     return CA_STATUS_OK;
 378 }
 379
 380 void CATerminateEDR()
 381 {
 382     // Terminate EDR Network Monitor
 383     CAEDRTerminateNetworkMonitor();
 384
 385     // Terminate Send/Receive data messages queues
 386     CAAdapterTerminateQueues();
 387
 388     g_networkPacketReceivedCallback = NULL;
 389     g_networkChangeCallback = NULL;
 390
 391     // Terminate thread pool
 392     g_edrThreadPool = NULL;
 393
 394     // Terminate EDR Client
 395     CAEDRClientTerminate();
 396
 397     // Terminate EDR Server
 398     CAEDRServerTerminate();
 399
 400     // Free LocalConnectivity information
 401     CAFreeEndpoint(g_localConnectivity);
 402     g_localConnectivity = NULL;
 403 }
 404
 405 CAResult_t CAStartServer()
 406 {
 407     if (false == g_adapterState)
 408     {
 409         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 410         // Setting g_serverState for starting Rfcommserver when adapter starts
 411         g_serverState = true;
 412         return CA_STATUS_OK;
 413     }
 414
 415     CAResult_t err = CA_STATUS_OK;
 416     if (CA_STATUS_OK != (err = CAEDRServerStart()))
 417     {
 418         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
 419                   err);
 420         return err;
 421     }
 422
 423     return err;
 424 }
 425
 426 CAResult_t CAEDRInitializeQueueHandlers()
 427 {
 428     if (CA_STATUS_OK == CAEDRInitializeSendHandler()
 429         && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
 430     {
 431         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
 432         return CA_STATUS_OK;
 433     }
 434
 435     return CA_STATUS_FAILED;
 436 }
 437
 438 CAResult_t CAEDRInitializeSendHandler()
 439 {
 440     // Check if the message queue is already initialized
 441     if (g_sendQueueHandle)
 442     {
 443         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 444         return CA_STATUS_OK;
 445     }
 446
 447     g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 448     if (!g_sendQueueHandle)
 449     {
 450         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 451         return CA_MEMORY_ALLOC_FAILED;
 452     }
 453
 454     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
 455                                                    CAAdapterDataSendHandler, CAEDRDataDestroyer))
 456     {
 457         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 458         return CA_STATUS_FAILED;
 459     }
 460     return CA_STATUS_OK;
 461 }
 462
 463 CAResult_t CAEDRInitializeReceiveHandler()
 464 {
 465     // Check if the message queue is already initialized
 466     if (g_recvQueueHandle)
 467     {
 468         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 469         return CA_STATUS_OK;
 470     }
 471
 472     g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 473     if (!g_recvQueueHandle)
 474     {
 475         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 476         return CA_MEMORY_ALLOC_FAILED;
 477     }
 478
 479
 480     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
 481                                                    CAAdapterDataReceiverHandler,
 482                                                    CAEDRDataDestroyer))
 483     {
 484         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 485         OICFree(g_recvQueueHandle);
 486         g_recvQueueHandle = NULL;
 487         return CA_STATUS_FAILED;
 488     }
 489
 490     return CA_STATUS_OK;
 491 }
 492
 493 void CAAdapterTerminateQueues()
 494 {
 495     if (g_sendQueueHandle)
 496     {
 497         CAQueueingThreadDestroy(g_sendQueueHandle);
 498         g_sendQueueHandle = NULL;
 499     }
 500     if (g_recvQueueHandle)
 501     {
 502         CAQueueingThreadDestroy(g_recvQueueHandle);
 503         g_recvQueueHandle = NULL;
 504     }
 505 }
 506
 507 void CAAdapterDataSendHandler(void *context)
 508 {
 509     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
 510
 511     CAEDRData *message = (CAEDRData *) context;
 512     if (!message)
 513     {
 514         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 515         return;
 516     }
 517
 518     if (!message->remoteEndpoint)
 519     {
 520         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
 521         return;
 522     }
 523
 524     const char *remoteAddress = message->remoteEndpoint->addr;
 525     if(!remoteAddress)
 526     {
 527         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
 528         //Error cannot be sent if remote address is NULL
 529         return;
 530     }
 531
 532     CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
 533     if(CA_STATUS_OK != result)
 534     {
 535         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 536         CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
 537         return;
 538     }
 539
 540     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 541 }
 542
 543 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
 544                                uint32_t dataLength)
 545 {
 546     CAResult_t result = CA_SEND_FAILED;
 547
 548     // Send the first segment with the header.
 549     if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
 550     {
 551         result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
 552         if (CA_STATUS_OK != result)
 553         {
 554             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
 555             return result;
 556         }
 557     }
 558     else
 559     {
 560         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
 561         result = CAEDRClientSendMulticastData(data, dataLength);
 562
 563         if (CA_STATUS_OK != result)
 564         {
 565             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
 566             return result;
 567         }
 568     }
 569     return result;
 570 }
 571
 572 void CAAdapterDataReceiverHandler(void *context)
 573 {
 574     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
 575
 576     if (NULL == g_networkPacketReceivedCallback)
 577     {
 578         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "g_networkPacketReceivedCallback is NULL");
 579         return;
 580     }
 581
 582     CAEDRData *message = (CAEDRData *) context;
 583     if (NULL == message || NULL == message->remoteEndpoint)
 584     {
 585         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 586         return;
 587     }
 588
 589     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 590                                                           CA_ADAPTER_RFCOMM_BTEDR,
 591                                                           message->remoteEndpoint->addr,
 592                                                           0);
 593
 594     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
 595
 596     const CASecureEndpoint_t sep = { .endpoint = *remoteEndpoint };
 597
 598     g_networkPacketReceivedCallback(&sep, message->data, message->dataLen);
 599
 600     CAFreeEndpoint(remoteEndpoint);
 601
 602     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
 603 }
 604
 605 CAResult_t CAAdapterStartQueue()
 606 {
 607     // Start send queue thread
 608     if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
 609     {
 610         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
 611         CAEDRClientUnsetCallbacks();
 612         //Disconnect all the client connections
 613         CAEDRClientDisconnectAll();
 614         return CA_STATUS_FAILED;
 615     }
 616
 617     // Start receive queue thread
 618     if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
 619     {
 620         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
 621         CAEDRClientUnsetCallbacks();
 622         //Disconnect all the client connections
 623         CAEDRClientDisconnectAll();
 624         return CA_STATUS_FAILED;
 625     }
 626
 627     return CA_STATUS_OK;
 628 }
 629
 630 CAResult_t CAAdapterStopQueue()
 631 {
 632     //Stop send queue thread
 633     CAQueueingThreadStop(g_sendQueueHandle);
 634
 635     //Stop receive queue thread
 636     CAQueueingThreadStop(g_recvQueueHandle);
 637
 638     return CA_STATUS_OK;
 639 }
 640
 641 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
 642                        uint32_t *sentLength)
 643 {
 644     if (false == g_adapterState)
 645     {
 646         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 647         *sentLength = 0;
 648         return;
 649     }
 650
 651     // Input validation
 652     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 653     VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 654
 655     // Create remote endpoint
 656     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 657                                                           CA_ADAPTER_RFCOMM_BTEDR,
 658                                                           remoteAddress, 0);
 659     if (NULL == remoteEndpoint)
 660     {
 661         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 662         return;
 663     }
 664
 665     // Add message to data queue
 666     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 667     CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
 668     *sentLength = dataLength;
 669
 670     // Free remote endpoint
 671     CAFreeEndpoint(remoteEndpoint);
 672 }
 673
 674 void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
 675                        uint32_t dataLength, CAResult_t result)
 676 {
 677     // Input validation
 678     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 679
 680     // Create remote endpoint
 681     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
 682                                                            remoteAddress, 0);
 683     if (!remoteEndpoint)
 684     {
 685         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 686         return;
 687     }
 688
 689     g_errorCallback(remoteEndpoint, data, dataLength, result);
 690
 691     // Free remote endpoint
 692     CAFreeEndpoint(remoteEndpoint);
 693 }
 694
 695 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
 696                              uint32_t dataLength, uint32_t *sentLength)
 697 {
 698     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
 699
 700     if (false == g_adapterState)
 701     {
 702         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 703         *sentLength = 0;
 704         return CA_ADAPTER_NOT_ENABLED;
 705     }
 706     // Input validation
 707     VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 708     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 709     VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 710
 711     // Create remote endpoint
 712     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 713                                                           CA_ADAPTER_RFCOMM_BTEDR,
 714                                                           remoteAddress, 0);
 715     if (NULL == remoteEndpoint)
 716     {
 717         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 718         return CA_MEMORY_ALLOC_FAILED;
 719     }
 720
 721     // Add message to data queue
 722     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 723     CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
 724     *sentLength = dataLength;
 725
 726     // Free remote endpoint
 727     CAFreeEndpoint(remoteEndpoint);
 728
 729     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
 730     return CA_STATUS_OK;
 731 }
 732
 733 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
 734 {
 735     // Create localconnectivity
 736     if (NULL == g_localConnectivity)
 737     {
 738         CAEDRGetInterfaceInformation(&g_localConnectivity);
 739     }
 740
 741     if (CA_INTERFACE_UP == status)
 742     {
 743         if (false == g_adapterState)
 744         {
 745             // Get Bluetooth adapter state
 746             bool adapterState = false;
 747             if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 748             {
 749                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 750                 return;
 751             }
 752
 753             if (false == adapterState)
 754             {
 755                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 756                 g_adapterState = false;
 757                 return;
 758             }
 759             CAEDRClientSetCallbacks();
 760             g_adapterState = true;
 761             CAAdapterStartQueue();
 762             // starting RFCommServer
 763             if (true == g_serverState)
 764             {
 765                 CAStartServer();
 766                 g_serverState = false;
 767             }
 768         }
 769     }
 770     else
 771     {
 772         g_adapterState = false;
 773     }
 774
 775     // Notify to upper layer
 776     if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
 777     {
 778         // Add notification task to thread pool
 779         CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
 780         if (NULL != event)
 781         {
 782             if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
 783                                                         CAEDROnNetworkStatusChanged,event))
 784             {
 785                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
 786                 return;
 787             }
 788         }
 789     }
 790 }
 791
 792 void CAEDROnNetworkStatusChanged(void *context)
 793 {
 794     if (NULL == context)
 795     {
 796         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
 797         return;
 798     }
 799
 800     CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
 801
 802     // Notify to upper layer
 803     if (g_networkChangeCallback)
 804     {
 805         g_networkChangeCallback(networkEvent->info, networkEvent->status);
 806     }
 807
 808     // Free the created Network event
 809     CAEDRFreeNetworkEvent(networkEvent);
 810 }
 811
 812 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
 813                                            CANetworkStatus_t status)
 814 {
 815     VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
 816
 817     // Create CAEDRNetworkEvent
 818     CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
 819     if (NULL == event)
 820     {
 821         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
 822         return NULL;
 823     }
 824
 825     // Create duplicate of Local connectivity
 826     event->info = CACloneEndpoint(connectivity);
 827     event->status = status;
 828     return event;
 829 }
 830
 831 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
 832 {
 833     if (event)
 834     {
 835         CAFreeEndpoint(event->info);
 836         OICFree(event);
 837     }
 838 }
 839
 840 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
 841                            const uint8_t *data, uint32_t dataLength)
 842 {
 843     CAEDRData *edrData = (CAEDRData *) OICCalloc(1, sizeof(*edrData));
 844     if (!edrData)
 845     {
 846         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 847         return NULL;
 848     }
 849
 850     edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
 851
 852     edrData->data = OICMalloc(dataLength);
 853     if (NULL == edrData->data)
 854     {
 855         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 856         CAFreeEDRData(edrData);
 857         return NULL;
 858     }
 859     memcpy(edrData->data, data, dataLength);
 860     edrData->dataLen = dataLength;
 861
 862     return edrData;
 863 }
 864
 865 void CAFreeEDRData(CAEDRData *edrData)
 866 {
 867     VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
 868
 869     CAFreeEndpoint(edrData->remoteEndpoint);
 870     OICFree(edrData->data);
 871     OICFree(edrData);
 872 }
 873
 874 void CAEDRDataDestroyer(void *data, uint32_t size)
 875 {
 876     if ((size_t)size < sizeof(CAEDRData))
 877     {
 878         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d", data, size);
 879     }
 880     CAEDRData *edrdata = (CAEDRData *) data;
 881
 882     CAFreeEDRData(edrdata);
 883 }