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     // 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     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 396 }
 397
 398 CAResult_t CAStartServer()
 399 {
 400     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 401
 402     CAResult_t err = CA_STATUS_OK;
 403
 404     if (false == g_adapterState)
 405     {
 406         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 407         // Setting g_serverState for starting Rfcommserver when adapter starts
 408         g_serverState = true;
 409         return CA_STATUS_OK;
 410     }
 411
 412     if (CA_STATUS_OK != (err = CAEDRServerStart(g_edrThreadPool)))
 413     {
 414         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Failed to start RFCOMM server!, error num [%d]",
 415                   err);
 416         return err;
 417     }
 418
 419     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 420     return err;
 421 }
 422
 423 CAResult_t CAEDRInitializeQueueHandlers()
 424 {
 425     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 426
 427     if (CA_STATUS_OK == CAEDRInitializeSendHandler()
 428         && CA_STATUS_OK == CAEDRInitializeReceiveHandler())
 429     {
 430         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Queue is initialized!");
 431         return CA_STATUS_OK;
 432     }
 433
 434     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 435     return CA_STATUS_FAILED;
 436 }
 437
 438 CAResult_t CAEDRInitializeSendHandler()
 439 {
 440     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 441     // Check if the message queue is already initialized
 442     if (g_sendQueueHandle)
 443     {
 444         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 445         return CA_STATUS_OK;
 446     }
 447
 448     g_sendQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 449     if (!g_sendQueueHandle)
 450     {
 451         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 452         return CA_MEMORY_ALLOC_FAILED;
 453     }
 454
 455     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_sendQueueHandle, g_edrThreadPool,
 456                                                    CAAdapterDataSendHandler, CAEDRDataDestroyer))
 457     {
 458         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 459         return CA_STATUS_FAILED;
 460     }
 461     return CA_STATUS_OK;
 462 }
 463
 464 CAResult_t CAEDRInitializeReceiveHandler()
 465 {
 466     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 467     // Check if the message queue is already initialized
 468     if (g_recvQueueHandle)
 469     {
 470         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Already queue is initialized!");
 471         return CA_STATUS_OK;
 472     }
 473
 474     g_recvQueueHandle = (CAQueueingThread_t *) OICMalloc(sizeof(CAQueueingThread_t));
 475     if (!g_recvQueueHandle)
 476     {
 477         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 478         return CA_MEMORY_ALLOC_FAILED;
 479     }
 480
 481     if (CA_STATUS_OK != CAQueueingThreadInitialize(g_recvQueueHandle, g_edrThreadPool,
 482                                                    CAAdapterDataReceiverHandler,
 483                                                    CAEDRDataDestroyer))
 484     {
 485         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Initialize send queue thread");
 486         return CA_STATUS_FAILED;
 487     }
 488
 489     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 490     return CA_STATUS_OK;
 491 }
 492
 493 void CAAdapterTerminateQueues()
 494 {
 495     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 496
 497     if (g_sendQueueHandle)
 498     {
 499         CAQueueingThreadDestroy(g_sendQueueHandle);
 500         g_sendQueueHandle = NULL;
 501     }
 502     if (g_recvQueueHandle)
 503     {
 504         CAQueueingThreadDestroy(g_recvQueueHandle);
 505         g_recvQueueHandle = NULL;
 506     }
 507
 508     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 509 }
 510
 511 void CAAdapterDataSendHandler(void *context)
 512 {
 513     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterDataSendHandler");
 514
 515     CAEDRData *message = (CAEDRData *) context;
 516     if (NULL == message)
 517     {
 518         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 519         return;
 520     }
 521
 522     const char *remoteAddress = NULL;
 523
 524     if (NULL == message->remoteEndpoint)
 525     {
 526         OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "remoteEndpoint is not available");
 527         return;
 528     }
 529     else
 530     {
 531         remoteAddress = message->remoteEndpoint->addr;
 532     }
 533
 534     if(!remoteAddress)
 535     {
 536         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "EDR Send Message error");
 537         //Error cannot be sent if remote address is NULL
 538         return;
 539     }
 540
 541     CAResult_t result = CAEDRClientSendData(remoteAddress, message->data,
 542                                             message->dataLen);
 543     if(CA_STATUS_OK != result)
 544     {
 545         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "CAEDRClientSendData API failed");
 546         CAEDRErrorHandler(remoteAddress, message->data, message->dataLen, result);
 547         return;
 548     }
 549
 550     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 551 }
 552
 553 CAResult_t CAEDRClientSendData(const char *remoteAddress,
 554                                const uint8_t *data,
 555                                uint32_t dataLength)
 556 {
 557
 558     CAResult_t result = CA_SEND_FAILED;
 559
 560     // Send the first segment with the header.
 561     if ((NULL != remoteAddress) && (0 < strlen(remoteAddress))) //Unicast data
 562     {
 563         result = CAEDRClientSendUnicastData(remoteAddress, data, dataLength);
 564         if (CA_STATUS_OK != result)
 565         {
 566             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send unicast data !");
 567             return result;
 568         }
 569     }
 570     else
 571     {
 572         OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "sending multicast data : %s", data);
 573         result = CAEDRClientSendMulticastData(data, dataLength);
 574
 575         if (CA_STATUS_OK != result)
 576         {
 577             OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to send multicast data !");
 578             return result;
 579         }
 580     }
 581     return result;
 582 }
 583
 584 void CAAdapterDataReceiverHandler(void *context)
 585 {
 586     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN_CAAdapterDataReceiverHandler");
 587
 588     CAEDRData *message = (CAEDRData *) context;
 589     if (NULL == message || NULL == message->remoteEndpoint)
 590     {
 591         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get message!");
 592         return;
 593     }
 594
 595     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 596                                                           CA_ADAPTER_RFCOMM_BTEDR,
 597                                                           message->remoteEndpoint->addr,
 598                                                           0);
 599
 600     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "Sending data up !");
 601     g_networkPacketReceivedCallback(remoteEndpoint, message->data, message->dataLen);
 602
 603     CAFreeEndpoint(remoteEndpoint);
 604
 605     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT_CAAdapterDataReceiverHandler");
 606 }
 607
 608 CAResult_t CAAdapterStartQueue()
 609 {
 610     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 611     // Start send queue thread
 612     if (CA_STATUS_OK != CAQueueingThreadStart(g_sendQueueHandle))
 613     {
 614         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Send Data Thread");
 615         CAEDRClientUnsetCallbacks();
 616         //Disconnect all the client connections
 617         CAEDRClientDisconnectAll();
 618         return CA_STATUS_FAILED;
 619     }
 620
 621     // Start receive queue thread
 622     if (CA_STATUS_OK != CAQueueingThreadStart(g_recvQueueHandle))
 623     {
 624         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to Start Receive Data Thread");
 625         CAEDRClientUnsetCallbacks();
 626         //Disconnect all the client connections
 627         CAEDRClientDisconnectAll();
 628         return CA_STATUS_FAILED;
 629     }
 630     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 631     return CA_STATUS_OK;
 632 }
 633
 634 CAResult_t CAAdapterStopQueue()
 635 {
 636     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 637     //Stop send queue thread
 638     CAQueueingThreadStop(g_sendQueueHandle);
 639
 640     //Stop receive queue thread
 641     CAQueueingThreadStop(g_recvQueueHandle);
 642     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 643     return CA_STATUS_OK;
 644 }
 645
 646 void CAAdapterRecvData(const char *remoteAddress, const uint8_t *data, uint32_t dataLength,
 647                        uint32_t *sentLength)
 648 {
 649     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 650
 651     if (false == g_adapterState)
 652     {
 653         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 654         *sentLength = 0;
 655         return;
 656     }
 657
 658     // Input validation
 659     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 660     VERIFY_NON_NULL_VOID(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 661
 662     // Create remote endpoint
 663     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 664                                                           CA_ADAPTER_RFCOMM_BTEDR,
 665                                                           remoteAddress, 0);
 666     if (NULL == remoteEndpoint)
 667     {
 668         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 669         return;
 670     }
 671
 672     // Add message to data queue
 673     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 674     CAQueueingThreadAddData(g_recvQueueHandle, edrData, sizeof(CAEDRData));
 675     *sentLength = dataLength;
 676
 677     // Free remote endpoint
 678     CAFreeEndpoint(remoteEndpoint);
 679
 680     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 681 }
 682
 683 void CAEDRErrorHandler(const char *remoteAddress, const uint8_t *data,
 684                        uint32_t dataLength, CAResult_t result)
 685 {
 686     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 687
 688     // Input validation
 689     VERIFY_NON_NULL_VOID(data, EDR_ADAPTER_TAG, "Data is null");
 690
 691     // Create remote endpoint
 692     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(0, CA_ADAPTER_RFCOMM_BTEDR,
 693                                                            remoteAddress, 0);
 694     if (!remoteEndpoint)
 695     {
 696         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 697         return;
 698     }
 699
 700     g_errorCallback(remoteEndpoint, data, dataLength, result);
 701
 702     // Free remote endpoint
 703     CAFreeEndpoint(remoteEndpoint);
 704
 705     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 706 }
 707
 708 CAResult_t CAAdapterSendData(const char *remoteAddress, const char *serviceUUID, const uint8_t *data,
 709                              uint32_t dataLength, uint32_t *sentLength)
 710 {
 711     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN - CAAdapterSendData");
 712
 713     if (false == g_adapterState)
 714     {
 715         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 716         *sentLength = 0;
 717         return CA_ADAPTER_NOT_ENABLED;
 718     }
 719     // Input validation
 720     VERIFY_NON_NULL(serviceUUID, EDR_ADAPTER_TAG, "service UUID is null");
 721     VERIFY_NON_NULL(data, EDR_ADAPTER_TAG, "Data is null");
 722     VERIFY_NON_NULL(sentLength, EDR_ADAPTER_TAG, "Sent data length holder is null");
 723
 724     // Create remote endpoint
 725     CAEndpoint_t *remoteEndpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS,
 726                                                           CA_ADAPTER_RFCOMM_BTEDR,
 727                                                           remoteAddress, 0);
 728     if (NULL == remoteEndpoint)
 729     {
 730         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create remote endpoint !");
 731         return CA_MEMORY_ALLOC_FAILED;
 732     }
 733
 734     // Add message to data queue
 735     CAEDRData *edrData =  CACreateEDRData(remoteEndpoint, data, dataLength);
 736     CAQueueingThreadAddData(g_sendQueueHandle, edrData, sizeof (CAEDRData));
 737     *sentLength = dataLength;
 738
 739     // Free remote endpoint
 740     CAFreeEndpoint(remoteEndpoint);
 741
 742     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT - CAAdapterSendData");
 743     return CA_STATUS_OK;
 744 }
 745
 746 void CAEDRNotifyNetworkStatus(CANetworkStatus_t status)
 747 {
 748     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 749
 750     // Create localconnectivity
 751     if (NULL == g_localConnectivity)
 752     {
 753         CAEDRGetInterfaceInformation(&g_localConnectivity);
 754     }
 755
 756     if (CA_INTERFACE_UP == status)
 757     {
 758         if (false == g_adapterState)
 759         {
 760             // Get Bluetooth adapter state
 761             bool adapterState = false;
 762             if (CA_STATUS_OK != CAEDRGetAdapterEnableState(&adapterState))
 763             {
 764                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to get adapter enable state");
 765                 return;
 766             }
 767
 768             if (false== adapterState)
 769             {
 770                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Bluetooth adapter is disabled!");
 771                 g_adapterState = false;
 772                 return;
 773             }
 774             CAEDRClientSetCallbacks();
 775             g_adapterState = true;
 776             CAAdapterStartQueue();
 777             // starting RFCommServer
 778             if (true == g_serverState)
 779             {
 780                 CAStartServer();
 781                 g_serverState = false;
 782             }
 783         }
 784     }
 785     else
 786     {
 787         g_adapterState = false;
 788     }
 789
 790     // Notify to upper layer
 791     if (g_networkChangeCallback && g_localConnectivity && g_edrThreadPool)
 792     {
 793         // Add notification task to thread pool
 794         CAEDRNetworkEvent *event = CAEDRCreateNetworkEvent(g_localConnectivity, status);
 795         if (NULL != event)
 796         {
 797             if (CA_STATUS_OK != ca_thread_pool_add_task(g_edrThreadPool,
 798                                                         CAEDROnNetworkStatusChanged,event))
 799             {
 800                 OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to create threadpool!");
 801                 return;
 802             }
 803         }
 804     }
 805
 806     OIC_LOG_V(DEBUG, EDR_ADAPTER_TAG, "OUT");
 807 }
 808
 809 void CAEDROnNetworkStatusChanged(void *context)
 810 {
 811     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "IN");
 812
 813     if (NULL == context)
 814     {
 815         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "context is NULL!");
 816         return;
 817     }
 818
 819     CAEDRNetworkEvent *networkEvent = (CAEDRNetworkEvent *) context;
 820
 821     // Notify to upper layer
 822     if (g_networkChangeCallback)
 823     {
 824         g_networkChangeCallback(networkEvent->info, networkEvent->status);
 825     }
 826
 827     // Free the created Network event
 828     CAEDRFreeNetworkEvent(networkEvent);
 829
 830     OIC_LOG(DEBUG, EDR_ADAPTER_TAG, "OUT");
 831 }
 832
 833 CAEDRNetworkEvent *CAEDRCreateNetworkEvent(CAEndpoint_t *connectivity,
 834                                            CANetworkStatus_t status)
 835 {
 836     VERIFY_NON_NULL_RET(connectivity, EDR_ADAPTER_TAG, "connectivity is NULL", NULL);
 837
 838     // Create CAEDRNetworkEvent
 839     CAEDRNetworkEvent *event = (CAEDRNetworkEvent *) OICMalloc(sizeof(CAEDRNetworkEvent));
 840     if (NULL == event)
 841     {
 842         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Failed to allocate memory to network event!");
 843         return NULL;
 844     }
 845
 846     // Create duplicate of Local connectivity
 847     event->info = CACloneEndpoint(connectivity);
 848     event->status = status;
 849     return event;
 850 }
 851
 852 void CAEDRFreeNetworkEvent(CAEDRNetworkEvent *event)
 853 {
 854     if (event)
 855     {
 856         CAFreeEndpoint(event->info);
 857         OICFree(event);
 858     }
 859 }
 860
 861 CAEDRData *CACreateEDRData(const CAEndpoint_t *remoteEndpoint,
 862                                         const uint8_t *data, uint32_t dataLength)
 863 {
 864     CAEDRData *edrData = (CAEDRData *)OICMalloc(sizeof (CAEDRData));
 865     if (!edrData)
 866     {
 867         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 868         return NULL;
 869     }
 870
 871     edrData->remoteEndpoint = CACloneEndpoint(remoteEndpoint);
 872
 873     edrData->data = OICMalloc(dataLength);
 874     if (NULL == edrData->data)
 875     {
 876         OIC_LOG(ERROR, EDR_ADAPTER_TAG, "Memory allocation failed!");
 877         CAFreeEDRData(edrData);
 878         return NULL;
 879     }
 880     memcpy(edrData->data, data, dataLength);
 881     edrData->dataLen = dataLength;
 882
 883     return edrData;
 884 }
 885
 886 void CAFreeEDRData(CAEDRData *edrData)
 887 {
 888     VERIFY_NON_NULL_VOID(edrData, EDR_ADAPTER_TAG, "edrData is NULL");
 889
 890     CAFreeEndpoint(edrData->remoteEndpoint);
 891     OICFree(edrData->data);
 892     OICFree(edrData);
 893 }
 894
 895 void CAEDRDataDestroyer(void *data, uint32_t size)
 896 {
 897     if ((size_t)size < sizeof(CAEDRData))
 898     {
 899         OIC_LOG_V(ERROR, EDR_ADAPTER_TAG, "Destroy data too small %p %d",
 900                   data, size);
 901     }
 902     CAEDRData *edrdata = (CAEDRData *) data;
 903
 904     CAFreeEDRData(edrdata);
 905 }