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