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     return CAStartServer();
 267 }
 268
 269 int32_t CASendEDRUnicastData(const CAEndpoint_t *remoteEndpoint, const void *data,
 270                              uint32_t dataLength)
 271 {
 272     // Input validation
 273     VERIFY_NON_NULL_RET(remoteEndpoint, EDR_ADAPTER_TAG, "Remote endpoint is null", -1);
 274     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 275
 276     if (0 == dataLength)
 277     {
 278         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 279         return -1;
 280     }
 281
 282     if (0 == strlen(remoteEndpoint->addr))
 283     {
 284         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: EDR Address is empty!");
 285         return -1;
 286     }
 287
 288     uint32_t sentLength = 0;
 289     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 290     const char *address = remoteEndpoint->addr;
 291     CAResult_t err = CAAdapterSendData(address, serviceUUID, data, dataLength, &sentLength);
 292     if (CA_STATUS_OK != err)
 293     {
 294         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send unicast data failed!, error num [%d]", err);
 295         g_errorCallback(remoteEndpoint, data, dataLength, err);
 296         return -1;
 297     }
 298
 299     return sentLength;
 300 }
 301
 302 int32_t CASendEDRMulticastData(const CAEndpoint_t *endpoint, const void *data, uint32_t dataLength)
 303 {
 304     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CASendEDRMulticastData");
 305
 306     // Input validation
 307     VERIFY_NON_NULL_RET(data, EDR_ADAPTER_TAG, "Data is null", -1);
 308
 309     if (0 == dataLength)
 310     {
 311         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Invalid input: data length is zero!");
 312         return -1;
 313     }
 314
 315     uint32_t sentLen = 0;
 316     const char *serviceUUID = OIC_EDR_SERVICE_ID;
 317     CAResult_t err = CAAdapterSendData(NULL, serviceUUID, data, dataLength, &sentLen);
 318     if (CA_STATUS_OK != err)
 319     {
 320         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Send multicast data failed!, error num [%d]", err);
 321         g_errorCallback(endpoint, data, dataLength, err);
 322         return -1;
 323     }
 324
 325     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CASendEDRMulticastData");
 326     return sentLen;
 327 }
 328
 329 CAResult_t CAGetEDRInterfaceInformation(CAEndpoint_t **info, uint32_t *size)
 330 {
 331     VERIFY_NON_NULL(info, EDR_ADAPTER_TAG, "LocalConnectivity info is null");
 332
 333     CAResult_t err = CA_STATUS_OK;
 334     *size = 0;
 335     if (CA_STATUS_OK != (err = CAEDRGetInterfaceInformation(info)))
 336     {
 337         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG,
 338                   "Failed to get local interface information!, error num [%d]", err);
 339         return err;
 340     }
 341
 342     *size = 1;
 343     return err;
 344 }
 345
 346 CAResult_t CAReadEDRData()
 347 {
 348     return CAEDRManagerReadData();
 349 }
 350
 351 CAResult_t CAStopEDR()
 352 {
 353     // Stop RFComm server if it is running
 354     CAEDRServerStop();
 355
 356     // Stop network monitor
 357     CAEDRStopNetworkMonitor();
 358
 359     // Stop the adapter
 360     CAEDRClientUnsetCallbacks();
 361
 362     // Disconnect all the client connections
 363     CAEDRClientDisconnectAll();
 364
 365     // Stop Send and receive Queue
 366     CAAdapterStopQueue();
 367
 368     return CA_STATUS_OK;
 369 }
 370
 371 void CATerminateEDR()
 372 {
 373     // Terminate EDR Network Monitor
 374     CAEDRTerminateNetworkMonitor();
 375
 376     // Terminate Send/Receive data messages queues
 377     CAAdapterTerminateQueues();
 378
 379     g_networkPacketReceivedCallback = NULL;
 380     g_networkChangeCallback = NULL;
 381
 382     // Terminate thread pool
 383     g_edrThreadPool = NULL;
 384
 385     // Terminate EDR Client
 386     CAEDRClientTerminate();
 387
 388     // Terminate EDR Server
 389     CAEDRServerTerminate();
 390
 391     // Free LocalConnectivity information
 392     CAFreeEndpoint(g_localConnectivity);
 393     g_localConnectivity = NULL;
 394 }
 395
 396 CAResult_t CAStartServer()
 397 {
 398     if (false == g_adapterState)
 399     {
 400         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 401         // Setting g_serverState for starting Rfcommserver when adapter starts
 402         g_serverState = true;
 403         return CA_STATUS_OK;
 404     }
 405
 406     CAResult_t err = CA_STATUS_OK;
 407     if (CA_STATUS_OK != (err = CAEDRServerStart()))
 408     {
 409         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
 410                   err);
 411         return err;
 412     }
 413
 414     return err;
 415 }
 416
 417 CAResult_t CAEDRInitializeQueueHandlers()
 418 {
 419     if (CA_STATUS_OK == CAEDRInitializeSendHandler()
 420         && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
 421     {
 422         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
 423         return CA_STATUS_OK;
 424     }
 425
 426     return CA_STATUS_FAILED;
 427 }
 428
 429 CAResult_t CAEDRInitializeSendHandler()
 430 {
 431     // Check if the message queue is already initialized
 432     if (g_sendQueueHandle)
 433     {
 434         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 435         return CA_STATUS_OK;
 436     }
 437
 438     g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 439     if (!g_sendQueueHandle)
 440     {
 441         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 442         return CA_MEMORY_ALLOC_FAILED;
 443     }
 444
 445     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
 446                                                    CAAdapterDataSendHandler, CAEDRDataDestroyer))
 447     {
 448         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 449         return CA_STATUS_FAILED;
 450     }
 451     return CA_STATUS_OK;
 452 }
 453
 454 CAResult_t CAEDRInitializeReceiveHandler()
 455 {
 456     // Check if the message queue is already initialized
 457     if (g_recvQueueHandle)
 458     {
 459         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 460         return CA_STATUS_OK;
 461     }
 462
 463     g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 464     if (!g_recvQueueHandle)
 465     {
 466         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 467         return CA_MEMORY_ALLOC_FAILED;
 468     }
 469
 470
 471     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
 472                                                    CAAdapterDataReceiverHandler,
 473                                                    CAEDRDataDestroyer))
 474     {
 475         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 476         OICFree(g_recvQueueHandle);
 477         g_recvQueueHandle = NULL;
 478         return CA_STATUS_FAILED;
 479     }
 480
 481     return CA_STATUS_OK;
 482 }
 483
 484 void CAAdapterTerminateQueues()
 485 {
 486     if (g_sendQueueHandle)
 487     {
 488         CAQueueingThreadDestroy(g_sendQueueHandle);
 489         g_sendQueueHandle = NULL;
 490     }
 491     if (g_recvQueueHandle)
 492     {
 493         CAQueueingThreadDestroy(g_recvQueueHandle);
 494         g_recvQueueHandle = NULL;
 495     }
 496 }
 497
 498 void CAAdapterDataSendHandler(void *context)
 499 {
 500     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
 501
 502     CAEDRData *message = (CAEDRData *) context;
 503     if (!message)
 504     {
 505         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 506         return;
 507     }
 508
 509     if (!message->remoteEndpoint)
 510     {
 511         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
 512         return;
 513     }
 514
 515     const char *remoteAddress = message->remoteEndpoint->addr;
 516     if(!remoteAddress)
 517     {
 518         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
 519         //Error cannot be sent if remote address is NULL
 520         return;
 521     }
 522
 523     CAResult_t result = CAEDRClientSendData(remoteAddress, message->data, message->dataLen);
 524     if(CA_STATUS_OK != result)
 525     {
 526         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 527         CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
 528         return;
 529     }
 530
 531     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 532 }
 533
 534 CAResult_t CAEDRClientSendData(const char *remoteAddress, const uint8_t *data,
 535                                uint32_t dataLength)
 536 {
 537     CAResult_t result = CA_SEND_FAILED;
 538
 539     // Send the first segment with the header.
 540     if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
 541     {
 542         result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
 543         if (CA_STATUS_OK != result)
 544         {
 545             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
 546             return result;
 547         }
 548     }
 549     else
 550     {
 551         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
 552         result = CAEDRClientSendMulticastData(data, dataLength);
 553
 554         if (CA_STATUS_OK != result)
 555         {
 556             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
 557             return result;
 558         }
 559     }
 560     return result;
 561 }
 562
 563 void CAAdapterDataReceiverHandler(void *context)
 564 {
 565     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
 566
 567     if (NULL == g_networkPacketReceivedCallback)
 568     {
 569         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "g_networkPacketReceivedCallback is NULL");
 570         return;
 571     }
 572
 573     CAEDRData *message = (CAEDRData *) context;
 574     if (NULL == message || NULL == message->remoteEndpoint)
 575     {
 576         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 577         return;
 578     }
 579
 580     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 581                                                           CA_ADAPTER_RFCOMM_BTEDR,
 582                                                           message->remoteEndpoint->addr,
 583                                                           0);
 584
 585     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
 586     g_networkPacketReceivedCallback(remoteEndpoint, message->data, message->dataLen);
 587
 588     CAFreeEndpoint(remoteEndpoint);
 589
 590     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
 591 }
 592
 593 CAResult_t CAAdapterStartQueue()
 594 {
 595     // Start send queue thread
 596     if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
 597     {
 598         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
 599         CAEDRClientUnsetCallbacks();
 600         //Disconnect all the client connections
 601         CAEDRClientDisconnectAll();
 602         return CA_STATUS_FAILED;
 603     }
 604
 605     // Start receive queue thread
 606     if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
 607     {
 608         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
 609         CAEDRClientUnsetCallbacks();
 610         //Disconnect all the client connections
 611         CAEDRClientDisconnectAll();
 612         return CA_STATUS_FAILED;
 613     }
 614
 615     return CA_STATUS_OK;
 616 }
 617
 618 CAResult_t CAAdapterStopQueue()
 619 {
 620     //Stop send queue thread
 621     CAQueueingThreadStop(g_sendQueueHandle);
 622
 623     //Stop receive queue thread
 624     CAQueueingThreadStop(g_recvQueueHandle);
 625
 626     return CA_STATUS_OK;
 627 }
 628
 629 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
 630                        uint32_t *sentLength)
 631 {
 632     if (false == g_adapterState)
 633     {
 634         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 635         *sentLength = 0;
 636         return;
 637     }
 638
 639     // Input validation
 640     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 641     VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 642
 643     // Create remote endpoint
 644     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 645                                                           CA_ADAPTER_RFCOMM_BTEDR,
 646                                                           remoteAddress, 0);
 647     if (NULL == remoteEndpoint)
 648     {
 649         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 650         return;
 651     }
 652
 653     // Add message to data queue
 654     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 655     CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
 656     *sentLength = dataLength;
 657
 658     // Free remote endpoint
 659     CAFreeEndpoint(remoteEndpoint);
 660 }
 661
 662 void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
 663                        uint32_t dataLength, CAResult_t result)
 664 {
 665     // Input validation
 666     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 667
 668     // Create remote endpoint
 669     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
 670                                                            remoteAddress, 0);
 671     if (!remoteEndpoint)
 672     {
 673         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 674         return;
 675     }
 676
 677     g_errorCallback(remoteEndpoint, data, dataLength, result);
 678
 679     // Free remote endpoint
 680     CAFreeEndpoint(remoteEndpoint);
 681 }
 682
 683 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
 684                              uint32_t dataLength, uint32_t *sentLength)
 685 {
 686     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
 687
 688     if (false == g_adapterState)
 689     {
 690         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 691         *sentLength = 0;
 692         return CA_ADAPTER_NOT_ENABLED;
 693     }
 694     // Input validation
 695     VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 696     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 697     VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 698
 699     // Create remote endpoint
 700     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 701                                                           CA_ADAPTER_RFCOMM_BTEDR,
 702                                                           remoteAddress, 0);
 703     if (NULL == remoteEndpoint)
 704     {
 705         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 706         return CA_MEMORY_ALLOC_FAILED;
 707     }
 708
 709     // Add message to data queue
 710     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 711     CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
 712     *sentLength = dataLength;
 713
 714     // Free remote endpoint
 715     CAFreeEndpoint(remoteEndpoint);
 716
 717     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
 718     return CA_STATUS_OK;
 719 }
 720
 721 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
 722 {
 723     // Create localconnectivity
 724     if (NULL == g_localConnectivity)
 725     {
 726         CAEDRGetInterfaceInformation(&g_localConnectivity);
 727     }
 728
 729     if (CA_INTERFACE_UP == status)
 730     {
 731         if (false == g_adapterState)
 732         {
 733             // Get Bluetooth adapter state
 734             bool adapterState = false;
 735             if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 736             {
 737                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 738                 return;
 739             }
 740
 741             if (false == adapterState)
 742             {
 743                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 744                 g_adapterState = false;
 745                 return;
 746             }
 747             CAEDRClientSetCallbacks();
 748             g_adapterState = true;
 749             CAAdapterStartQueue();
 750             // starting RFCommServer
 751             if (true == g_serverState)
 752             {
 753                 CAStartServer();
 754                 g_serverState = false;
 755             }
 756         }
 757     }
 758     else
 759     {
 760         g_adapterState = false;
 761     }
 762
 763     // Notify to upper layer
 764     if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
 765     {
 766         // Add notification task to thread pool
 767         CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
 768         if (NULL != event)
 769         {
 770             if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
 771                                                         CAEDROnNetworkStatusChanged,event))
 772             {
 773                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
 774                 return;
 775             }
 776         }
 777     }
 778 }
 779
 780 void CAEDROnNetworkStatusChanged(void *context)
 781 {
 782     if (NULL == context)
 783     {
 784         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
 785         return;
 786     }
 787
 788     CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
 789
 790     // Notify to upper layer
 791     if (g_networkChangeCallback)
 792     {
 793         g_networkChangeCallback(networkEvent->info, networkEvent->status);
 794     }
 795
 796     // Free the created Network event
 797     CAEDRFreeNetworkEvent(networkEvent);
 798 }
 799
 800 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
 801                                            CANetworkStatus_t status)
 802 {
 803     VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
 804
 805     // Create CAEDRNetworkEvent
 806     CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
 807     if (NULL == event)
 808     {
 809         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
 810         return NULL;
 811     }
 812
 813     // Create duplicate of Local connectivity
 814     event->info = CACloneEndpoint(connectivity);
 815     event->status = status;
 816     return event;
 817 }
 818
 819 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
 820 {
 821     if (event)
 822     {
 823         CAFreeEndpoint(event->info);
 824         OICFree(event);
 825     }
 826 }
 827
 828 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
 829                            const uint8_t *data, uint32_t dataLength)
 830 {
 831     CAEDRData *edrData = (CAEDRData *) OICCalloc(1, sizeof(*edrData));
 832     if (!edrData)
 833     {
 834         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 835         return NULL;
 836     }
 837
 838     edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
 839
 840     edrData->data = OICMalloc(dataLength);
 841     if (NULL == edrData->data)
 842     {
 843         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 844         CAFreeEDRData(edrData);
 845         return NULL;
 846     }
 847     memcpy(edrData->data, data, dataLength);
 848     edrData->dataLen = dataLength;
 849
 850     return edrData;
 851 }
 852
 853 void CAFreeEDRData(CAEDRData *edrData)
 854 {
 855     VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
 856
 857     CAFreeEndpoint(edrData->remoteEndpoint);
 858     OICFree(edrData->data);
 859     OICFree(edrData);
 860 }
 861
 862 void CAEDRDataDestroyer(void *data, uint32_t size)
 863 {
 864     if ((size_t)size < sizeof(CAEDRData))
 865     {
 866         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d", data, size);
 867     }
 868     CAEDRData *edrdata = (CAEDRData *) data;
 869
 870     CAFreeEDRData(edrdata);
 871 }