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