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