src/Bluetooth/BluetoothAdapter.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <pcrecpp.h>
  19
  20 #include <Logger.h>
  21 #include <JSWebAPIErrorFactory.h>
  22 #include <JSUtil.h>
  23 #include <TimeTracer.h>
  24 #include "plugin_config_impl.h"
  25 #include "BluetoothAdapter.h"
  26 #include "BluetoothCallbackUtil.h"
  27 #include "JSBluetoothDevice.h"
  28 #include "JSBluetoothServiceHandler.h"
  29 #include "JSBluetoothSocket.h"
  30 #include "GlobalContextManager.h"
  31
  32 using namespace DeviceAPI::Common;
  33
  34 namespace DeviceAPI {
  35 namespace Bluetooth {
  36
  37 void BluetoothAdapter::onStateChangedCB(int result, bt_adapter_state_e adapterState, void *userData)
  38 {
  39     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
  40
  41     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
  42     if(!object) {
  43         LoggerW("userData is NULL");
  44         return;
  45     }
  46
  47     bool previousState = object->mEnabled;
  48     object->mEnabled = (adapterState == BT_ADAPTER_ENABLED) ? true : false;
  49     if(object->mEnabled == true) {
  50         object->mVisible = object->getVisible();
  51     }
  52
  53     // call onstatechanged in ChangeListener
  54     if(previousState != object->mEnabled && result == BT_ERROR_NONE && object->mChangeListener != NULL) {
  55         LoggerD("call onstatechanged in ChangeListener");
  56         object->mChangeListener->invokeCallback("onstatechanged", JSUtil::toJSValueRef(object->mChangeListener->getContext(), object->mEnabled));
  57     }
  58
  59     // call a result callback of setPowered()
  60     if(object->mUserDataList[SET_POWERED] != NULL) {  // requested event
  61         LoggerD("call a result callback of setPowered()");
  62         if(object->mRequestedState != object->mEnabled) {
  63             LoggerW("Requested state is not equal to current state");
  64             return;
  65         }
  66
  67         MultiCallbackUserDataPtr callback = static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[SET_POWERED]);
  68         object->mUserDataList[SET_POWERED].reset();
  69
  70         if(result == BT_ERROR_NONE) {
  71             if(callback)
  72                 callback->invokeCallback("success");
  73         }
  74         else if(result == BT_ERROR_RESOURCE_BUSY) {
  75             if(callback) {
  76                 JSContextRef context = callback->getContext();
  77                 ServiceNotAvailableException error("Bluetooth device is busy");
  78                 callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
  79             }
  80         }
  81         else {
  82             if(callback) {
  83                 JSContextRef context = callback->getContext();
  84                 UnknownException error("Unknown error");
  85                 callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
  86             }
  87         }
  88     }
  89     else {  // unexpected event
  90         LoggerW("Bluetooth state is changed unexpectedly");
  91     }
  92
  93     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
  94 }
  95
  96 void BluetoothAdapter::onNameChangedCB(char *name, void *userData)
  97 {
  98     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
  99
 100     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 101     if(!object) {
 102         LoggerW("userData is NULL");
 103         return;
 104     }
 105
 106     LoggerD("changed name: " << std::string(name));
 107     // call onnamechanged in ChangeListener
 108     if(object->mChangeListener != NULL) {
 109         LoggerD("call onnamechanged in ChangeListener");
 110         object->mChangeListener->invokeCallback("onnamechanged", JSUtil::toJSValueRef(object->mChangeListener->getContext(), std::string(name)));
 111     }
 112
 113     // call a result callback of setName()
 114     if(object->mUserDataList[SET_NAME] != NULL && !strcmp(object->mRequestedName.c_str(), name)) {  // requested event
 115         MultiCallbackUserDataPtr callback = static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[SET_NAME]);
 116         object->mUserDataList[SET_NAME].reset();
 117         if(callback)
 118             callback->invokeCallback("success");
 119
 120         //bt_adapter_unset_name_changed_cb();
 121     }
 122     else {  // unexpected event
 123         LoggerW("Bluetooth name is changed unexpectedly");
 124     }
 125
 126     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
 127 }
 128
 129 void BluetoothAdapter::onVisibilityChangedCB(int result, bt_adapter_visibility_mode_e visibilityMode, void *userData)
 130 {
 131     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
 132
 133     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 134     if(!object) {
 135         LoggerW("userData is NULL");
 136         return;
 137     }
 138
 139     bool previousVisible = object->mVisible;
 140     object->mVisible = (visibilityMode != BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) ? true : false;
 141
 142     // call onvisibilitychanged in ChangeListener
 143     if(object->mChangeListener != NULL) {
 144         if(previousVisible != object->mVisible) {
 145             LoggerD("call onvisibilitychanged in ChangeListener");
 146             object->mChangeListener->invokeCallback("onvisibilitychanged", JSUtil::toJSValueRef(object->mChangeListener->getContext(), object->mVisible));
 147         }
 148     }
 149
 150     // call a result callback of setVisible()
 151     if(object->mUserDataList[SET_VISIBLE] != NULL) {  // requested event
 152         //bool visibility = (visibilityMode == BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) ? false : true;
 153         if(object->mRequestedVisibility != visibilityMode) {
 154             LoggerW("Requested visibility is not same to current visibility");
 155             return;
 156         }
 157
 158         MultiCallbackUserDataPtr callback = static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[SET_VISIBLE]);
 159         object->mUserDataList[SET_VISIBLE].reset();
 160
 161         if(result == BT_ERROR_NONE) {
 162             if(callback)
 163                 callback->invokeCallback("success");
 164         }
 165         else {
 166             if(callback) {
 167                 JSContextRef context = callback->getContext();
 168                 UnknownException error("Unknown error");
 169                 callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
 170             }
 171         }
 172
 173         //bt_adapter_unset_visibility_mode_changed_cb();
 174     }
 175     else {  // unexpected event
 176         LoggerW("Bluetooth visibility is changed unexpectedly");
 177     }
 178
 179     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
 180 }
 181
 182 void BluetoothAdapter::onDiscoveryStateChangedCB(int result, bt_adapter_device_discovery_state_e discoveryState,
 183         bt_adapter_device_discovery_info_s *discoveryInfo, void *userData)
 184 {
 185     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 186     if(!object) {
 187         LoggerW("userData is NULL");
 188         return;
 189     }
 190
 191     switch(discoveryState) {
 192         case BT_ADAPTER_DEVICE_DISCOVERY_STARTED:
 193         {
 194             LoggerD("Discovery started");
 195             if(object->mUserDataList[DISCOVER_DEVICES] != NULL) {  // requested event
 196                 MultiCallbackUserDataPtr callback =
 197                         static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[DISCOVER_DEVICES]);
 198
 199                 if(result == BT_ERROR_NONE) {
 200
 201                     // store MAC address of previously found device into mDisappearedDevices
 202                     object->mDisappearedDevices.clear();
 203                     for(std::vector<BluetoothDeviceSharedPtr>::iterator iter = object->mFoundDevices.begin();
 204                             iter != object->mFoundDevices.end(); iter++) {
 205                         BluetoothDeviceSharedPtr foundDevice = *iter;
 206                         object->mDisappearedDevices.push_back(foundDevice->getAddress());
 207                     }
 208
 209                     object->mFoundDevices.clear();
 210                     if(callback)
 211                         callback->invokeCallback("onstarted");
 212                 }
 213                 else {
 214                     if(callback) {
 215                         object->mUserDataList[DISCOVER_DEVICES].reset();
 216
 217                         JSContextRef context = callback->getContext();
 218                         UnknownException error("Unknown error");
 219                         callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
 220                     }
 221
 222                     /*
 223                     if(object->mUserDataList[STOP_DISCOVERY] == NULL)    // because same core API callback is used
 224                         bt_adapter_unset_device_discovery_state_changed_cb();
 225                     */
 226                 }
 227             }
 228             else {  // unexpected event
 229                 LoggerW("Unexpected discovery");
 230             }
 231             break;
 232         }
 233         case BT_ADAPTER_DEVICE_DISCOVERY_FINISHED:
 234         {
 235             LoggerD("Discovery finished");
 236             if(result == BT_ERROR_NONE || result == BT_ERROR_CANCELLED) {
 237                 // in case of discoverDevices()
 238                 if(object->mUserDataList[DISCOVER_DEVICES] != NULL) {
 239                     MultiCallbackUserDataPtr callback =
 240                             static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[DISCOVER_DEVICES]);
 241
 242                     if(callback) {
 243                         if(object->mDisappearedDevices.size() > 0) {
 244                             LoggerD("There are disappeared devices");
 245                             for(std::vector<std::string>::iterator iter = object->mDisappearedDevices.begin();
 246                                     iter != object->mDisappearedDevices.end(); iter++) {
 247
 248                                 callback->invokeCallback("ondevicedisappeared",
 249                                         JSUtil::toJSValueRef(callback->getContext(), *iter));
 250                             }
 251                         }
 252
 253                         if(object->mFoundDevices.size() > 0) { // There are found devices
 254                             LoggerD("There are found devices");
 255                             int num = object->mFoundDevices.size();
 256                             JSObjectRef devices[num];
 257                             for(int i = 0; i < num; i++) {
 258                                 JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(callback->getContext(), object->mFoundDevices[i]);
 259                                 devices[i] = deviceObj;
 260                             }
 261
 262                             object->mUserDataList[DISCOVER_DEVICES].reset();
 263
 264                             callback->invokeCallback(
 265                                     "onfinished",
 266                                     JSObjectMakeArray(callback->getContext(), num, devices, NULL) );
 267                         }
 268                         else {  // There is no found device
 269                             LoggerD("There is no found device");
 270                             object->mUserDataList[DISCOVER_DEVICES].reset();
 271
 272                             callback->invokeCallback(
 273                                     "onfinished",
 274                                     JSObjectMakeArray(callback->getContext(), 0, NULL, NULL) );
 275                         }
 276                     }
 277                 }
 278
 279                 // in case of stopDiscovery()
 280                 if(object->mUserDataList[STOP_DISCOVERY] != NULL) {
 281                     MultiCallbackUserDataPtr callback =
 282                             static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[STOP_DISCOVERY]);
 283
 284                     if(callback) {
 285                         LoggerD("Call successCallback of stopDiscovery()");
 286                         object->mUserDataList[STOP_DISCOVERY].reset();
 287                         callback->invokeCallback("success");
 288                     }
 289                 }
 290
 291                 //bt_adapter_unset_device_discovery_state_changed_cb();
 292             }
 293             else {
 294                 LoggerW("Unexpected result of discovery finish");
 295             }
 296             break;
 297         }
 298         case BT_ADAPTER_DEVICE_DISCOVERY_FOUND:
 299         {
 300             LoggerD("A device is found");
 301             if(!discoveryInfo) {
 302                 LoggerW("No information about found device");
 303                 return;
 304             }
 305
 306             if(object->mUserDataList[DISCOVER_DEVICES] != NULL) {  // requested event
 307                 MultiCallbackUserDataPtr callback =
 308                         static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[DISCOVER_DEVICES]);
 309
 310                 if(result == BT_ERROR_NONE) {
 311                     // create BluetoothDevice
 312                     BluetoothDeviceSharedPtr device(new BluetoothDevice(discoveryInfo));
 313                                         device->copyAceCheckAccessFunction(getInstance());
 314                     JSContextRef context = callback->getContext();
 315                     JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(context, device);
 316                     object->mFoundDevices.push_back(device);
 317
 318                     // remove MAC address of found device from mDisappearedDevices
 319                     for(std::vector<std::string>::iterator iter = object->mDisappearedDevices.begin();
 320                             iter != object->mDisappearedDevices.end(); iter++) {
 321                         if(!strcmp(discoveryInfo->remote_address, (*iter).c_str())) {
 322                             object->mDisappearedDevices.erase(iter);
 323                             break;
 324                         }
 325                     }
 326
 327                     if(callback)
 328                         callback->invokeCallback("ondevicefound", deviceObj);
 329                 }
 330                 else {
 331                     LoggerW("Unexpected result of discovery");
 332                 }
 333             }
 334             else {  // unexpected event
 335                 LoggerW("Unexpected discovery");
 336             }
 337             break;
 338         }
 339         default:
 340         {
 341             LoggerW("Unknown state");
 342         }
 343     }
 344 }
 345
 346 bool BluetoothAdapter::foreachBondedDevicesCB(bt_device_info_s *deviceInfo, void *userData)
 347 {
 348     BluetoothAdapterPtr adapter = static_cast<BluetoothAdapterPtr>(userData);
 349     if(!adapter) {
 350         LoggerW("userData is NULL");
 351         return true;
 352     }
 353
 354     if(deviceInfo == NULL) {
 355         LoggerW("deviceInfo is NULL");
 356         return true;
 357     }
 358
 359     std::vector<BluetoothDeviceSharedPtr>::iterator iter;
 360     for(iter = adapter->knownDevices.begin(); iter != adapter->knownDevices.end(); ++iter) {
 361         BluetoothDeviceSharedPtr foundDevice = *iter;
 362
 363         if(!strcmp(foundDevice->getAddress().c_str(), deviceInfo->remote_address)) {
 364             foundDevice->updateInfo(deviceInfo);
 365             break;
 366         }
 367     }
 368
 369     if(iter == adapter->knownDevices.end()) {
 370         BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
 371                 device->copyAceCheckAccessFunction(getInstance());
 372         adapter->knownDevices.push_back(device);
 373     }
 374
 375     return true;
 376 }
 377
 378 void BluetoothAdapter::onBondCreatedCB(int result, bt_device_info_s *deviceInfo, void *userData)
 379 {
 380     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
 381
 382     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 383     if(!object) {
 384         LoggerW("userData is NULL");
 385         return;
 386     }
 387
 388     if(!deviceInfo) {
 389         LoggerW("deviceInfo is NULL");
 390         return;
 391     }
 392
 393     if(object->mUserDataList[CREATE_BONDING] != NULL &&
 394             !strcmp(object->mCreateBondingAddress.c_str(), deviceInfo->remote_address)) {  // requested event
 395
 396         MultiCallbackUserDataPtr callback = static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[CREATE_BONDING]);
 397         object->mUserDataList[CREATE_BONDING].reset();
 398
 399         if(result == BT_ERROR_NONE && deviceInfo != NULL) {
 400             if(callback) {
 401                 BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
 402                                 device->copyAceCheckAccessFunction(getInstance());
 403                 JSContextRef context = callback->getContext();
 404                 JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(context, device);
 405                 callback->invokeCallback("success", deviceObj);
 406             }
 407         }
 408         else if(result == BT_ERROR_REMOTE_DEVICE_NOT_FOUND) {
 409             if(callback) {
 410                 LoggerE("Not found");
 411                 JSContextRef context = callback->getContext();
 412                 NotFoundException error("Not found");
 413                 callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
 414             }
 415         }
 416         else {
 417             if(callback) {
 418                 JSContextRef context = callback->getContext();
 419                 UnknownException error("Unknown error");
 420                 callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
 421             }
 422         }
 423
 424         bt_device_unset_bond_created_cb();
 425         object->mCreateBondingAddress.clear();
 426     }
 427     else {  // unexpected event
 428         LoggerW("A bonding is created unexpectedly");
 429     }
 430
 431     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
 432 }
 433
 434 void BluetoothAdapter::onBondDestroyedCB(int result, char *remoteAddress, void *userData)
 435 {
 436     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
 437
 438     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 439     if(!object) {
 440         LoggerW("userData is NULL");
 441         return;
 442     }
 443
 444     if(object->mUserDataList[DESTROY_BONDING] != NULL &&
 445             !strcmp(object->mDestroyBondingAddress.c_str(), remoteAddress)) {  // requested event
 446
 447         MultiCallbackUserDataPtr callback = static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[DESTROY_BONDING]);
 448         object->mUserDataList[DESTROY_BONDING].reset();
 449
 450         if(result == BT_ERROR_NONE) {
 451             if(callback)
 452                 callback->invokeCallback("success");
 453         }
 454         else {
 455             if(callback) {
 456                 JSContextRef context = callback->getContext();
 457                 UnknownException error("Unknown error");
 458                 callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
 459             }
 460         }
 461
 462         bt_device_unset_bond_destroyed_cb();
 463         object->mDestroyBondingAddress.clear();
 464     }
 465     else {  // unexpected event
 466         LoggerW("A bonding is destroyed unexpectedly");
 467     }
 468
 469     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
 470 }
 471
 472 void BluetoothAdapter::onSocketConnected(int result, bt_socket_connection_state_e state, bt_socket_connection_s *connection, void *userData)
 473 {
 474     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
 475
 476     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 477     if(!object) {
 478         LoggerW("userData is NULL");
 479         return;
 480     }
 481
 482     if(!connection) {
 483         LoggerW("connection is NULL");
 484         return;
 485     }
 486
 487     if(connection->local_role == BT_SOCKET_SERVER) {
 488         RegisteredUUIDMapT::iterator iter = object->mRegisteredUUID.find(connection->service_uuid);
 489         if(iter == object->mRegisteredUUID.end()) {
 490             LoggerW("Connection state is changed unexpectedly");
 491             return;
 492         }
 493
 494         if(state == BT_SOCKET_CONNECTED) {  // connected when Server
 495             if(result == BT_ERROR_NONE) {
 496                 // Update BluetoothServiceHandler
 497                 BluetoothServiceHandlerPtr service = iter->second;
 498                 service->setConnectionState(true);
 499
 500                 // Call BluetoothServiceHandler.onconnect
 501                 BluetoothSocketPtr socket = new BluetoothSocket(connection, getInstance());
 502                 MultiCallbackUserDataPtr callback = service->getOnConnect();
 503                 JSContextRef context = callback->getContext();
 504                 JSObjectRef socketObj = JSBluetoothSocket::createJSObject(context, socket);
 505                 if(callback)
 506                     callback->invokeCallback("onconnect", socketObj);
 507
 508                 // Update mConnectedSocket
 509                 object->mConnectedSocket.insert(std::pair<int, BluetoothSocketPtr>(connection->socket_fd, socket));
 510                 bt_socket_set_data_received_cb(onSocketReceivedCB, userData);
 511             }
 512             else {
 513                 LoggerW("Establishing a connection failed");
 514             }
 515             return;
 516         }
 517         else {  // disconnected when Server
 518             if(result == BT_ERROR_NONE) {
 519                 // Update BluetoothServiceHandler
 520                 BluetoothServiceHandlerPtr service = iter->second;
 521                 service->setConnectionState(false);
 522
 523                 // call BluetoothSocket.onclose;
 524                 ConnectedSocketMapT::iterator i = object->mConnectedSocket.find(connection->socket_fd);
 525                 if(i == object->mConnectedSocket.end()) {
 526                     LoggerW("Unknown connected socket");
 527                     return;
 528                 }
 529                 //BluetoothSocketSharedPtr socket = i->second;
 530                 BluetoothSocketPtr socket = i->second;
 531                 socket->setConnectionState(false);
 532                 MultiCallbackUserDataPtr callback = socket->getOnClose();
 533                 if(callback)
 534                     callback->invokeCallback("onclose");
 535
 536                 // Update mConnectedSocket
 537                 object->mConnectedSocket.erase(i);
 538             }
 539             else {
 540                 LoggerW("Disconnecting a connection failed");
 541             }
 542         }
 543     }
 544     else if(connection->local_role == BT_SOCKET_CLIENT) {
 545
 546         if(state == BT_SOCKET_CONNECTED) {  // connected when Client
 547             std::string remoteAddress(connection->remote_address);
 548             ConnReqMultiMapT::iterator iter;
 549             do {
 550                 iter = object->mConnReqMap.find(remoteAddress);
 551                 if(iter != object->mConnReqMap.end() && !strcmp(iter->second->mUUID.c_str(), connection->service_uuid)) {
 552                     break;
 553                 }
 554             } while(iter != object->mConnReqMap.end());
 555
 556             if(iter == object->mConnReqMap.end()) {
 557                 LoggerW("Connection state is changed unexpectedly");
 558                 return;
 559             }
 560
 561             MultiCallbackUserDataPtr callback = static_cast<MultiCallbackUserDataPtr>(iter->second->mUserData);
 562
 563             if(result == BT_ERROR_NONE) {
 564                 // Update mConnectedSocket
 565                 BluetoothSocketPtr socket = new BluetoothSocket(connection, getInstance());
 566
 567                 object->mConnectedSocket.insert(std::pair<int, BluetoothSocketPtr>(connection->socket_fd, socket));
 568                 bt_socket_set_data_received_cb(onSocketReceivedCB, userData);
 569
 570                 // Call successcallback of connectToServiceByUUID
 571                 JSContextRef context = callback->getContext();
 572                 JSObjectRef socketObj = JSBluetoothSocket::createJSObject(context, socket);
 573                 if(callback)
 574                     callback->invokeCallback("success", socketObj);
 575
 576                 // Update mConnReqMap
 577                 object->mConnReqMap.erase(iter);
 578             }
 579             else {
 580                 // Call errorcallback of connectToServiceByUUID
 581                 JSContextRef context = callback->getContext();
 582                 NotFoundException error("Not found");
 583                 if(callback)
 584                     callback->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(context, error));
 585
 586                 // Update mConnReqMap
 587                 object->mConnReqMap.erase(iter);
 588             }
 589             return;
 590         }
 591         else {  // disconnected when Client
 592             if(result == BT_ERROR_NONE) {
 593                 // call BluetoothSocket.onclose;
 594                 ConnectedSocketMapT::iterator i = object->mConnectedSocket.find(connection->socket_fd);
 595                 if(i == object->mConnectedSocket.end()) {
 596                     LoggerW("Unknown connected socket");
 597                     return;
 598                 }
 599
 600                 BluetoothSocketPtr socket = i->second;
 601                 socket->setConnectionState(false);
 602                 MultiCallbackUserDataPtr callback = socket->getOnClose();
 603                 if(callback)
 604                     callback->invokeCallback("onclose");
 605
 606                 // Update mConnectedSocket
 607                 object->mConnectedSocket.erase(i);
 608             }
 609             else {
 610                 LoggerW("Disconnecting a connection failed");
 611             }
 612         }
 613     }
 614     else {
 615         LoggerW("Unknown role");
 616         return;
 617     }
 618
 619     if(object->mConnectedSocket.size() == 0) {
 620         bt_socket_unset_data_received_cb();
 621     }
 622
 623     if(object->mRegisteredUUID.size() == 0 && object->mConnReqMap.size() == 0 && object->mConnectedSocket.size() == 0) {
 624         bt_socket_unset_connection_state_changed_cb();
 625     }
 626
 627     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
 628 }
 629
 630 void BluetoothAdapter::onSocketReceivedCB(bt_socket_received_data_s *data, void *userData)
 631 {
 632     BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
 633     if(!object) {
 634         LoggerW("userData is NULL");
 635         return;
 636     }
 637
 638     if(!data) {
 639         LoggerW("data is NULL");
 640         return;
 641     }
 642
 643     ConnectedSocketMapT::iterator i = object->mConnectedSocket.find(data->socket_fd);
 644     if(i == object->mConnectedSocket.end()) {
 645         LoggerW("Unknown connected socket");
 646         return;
 647     }
 648
 649     // Store received data
 650     BluetoothSocketPtr socket = i->second;
 651     socket->storeRecivedData(data->data, static_cast<unsigned long>(data->data_size));
 652
 653     // Call BluetoothSocket.onmessage
 654     MultiCallbackUserDataPtr callback = socket->getOnMessage();
 655     if(callback)
 656         callback->invokeCallback("onmessage");
 657 }
 658
 659 BluetoothAdapter::BluetoothAdapter():
 660         mEnabled(false), mVisible(false)
 661 {
 662         Common::SecurityAccessor();
 663
 664     bt_adapter_state_e state;
 665     if (bt_adapter_get_state(&state) == BT_ERROR_NONE) {
 666         if (state == BT_ADAPTER_ENABLED) {
 667             mEnabled = true;
 668         }
 669     }
 670
 671     bt_adapter_visibility_mode_e mode;
 672     if (bt_adapter_get_visibility(&mode, NULL) == BT_ERROR_NONE) {
 673         if (mode != BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) {
 674             mVisible = true;
 675         }
 676     }
 677
 678     if(bt_adapter_set_state_changed_cb(onStateChangedCB, this) != BT_ERROR_NONE) {
 679         LoggerE("bt_adapter_set_state_changed_cb() failed");
 680     }
 681
 682     if(bt_adapter_set_device_discovery_state_changed_cb(onDiscoveryStateChangedCB, this) != BT_ERROR_NONE) {
 683         LoggerE("bt_adapter_set_device_discovery_state_changed_cb() failed");
 684     }
 685
 686     if(bt_adapter_set_name_changed_cb(onNameChangedCB, this) != BT_ERROR_NONE) {
 687         LoggerE("bt_adapter_set_name_changed_cb() failed");
 688     }
 689
 690     if(bt_adapter_set_visibility_mode_changed_cb(onVisibilityChangedCB, this) != BT_ERROR_NONE) {
 691         LoggerE("bt_adapter_set_visibility_mode_changed_cb() failed");
 692     }
 693 }
 694
 695 BluetoothAdapter::~BluetoothAdapter()
 696 {
 697     // unset platform callback
 698     bt_adapter_unset_state_changed_cb();
 699     bt_adapter_unset_name_changed_cb();
 700     bt_adapter_unset_visibility_mode_changed_cb();
 701     bt_adapter_unset_device_discovery_state_changed_cb();
 702     bt_device_unset_bond_created_cb();
 703     bt_device_unset_bond_destroyed_cb();
 704     bt_socket_unset_connection_state_changed_cb();
 705     bt_socket_unset_data_received_cb();
 706     bt_deinitialize();
 707
 708     for(int i = 0; i <= DESTROY_BONDING; i++) {
 709         mUserDataList[i].reset();
 710     }
 711     mRegisteredUUID.clear();
 712     mConnReqMap.clear();
 713     mFoundDevices.clear();
 714     mConnectedSocket.clear();
 715
 716
 717 }
 718
 719 void BluetoothAdapter::unloadFrame(JSContextRef context)
 720 {
 721     LoggerD("Clean mUserDataList");
 722     for(int i = 0; i <= DESTROY_BONDING; i++) {
 723         if(mUserDataList[i]) {
 724             MultiCallbackUserDataPtr callback = mUserDataList[i];
 725             if(!GlobalContextManager::getInstance()->isAliveGlobalContext(callback->getContext())) {
 726                 mUserDataList[i].reset();
 727             }
 728         }
 729     }
 730
 731     LoggerD("Clean mConnReqMap");
 732     for(ConnReqMultiMapT::iterator iter = mConnReqMap.begin(); iter != mConnReqMap.end(); ) {
 733         ConnReqMultiMapT::iterator temp = iter++;
 734         MultiCallbackUserDataPtr callback = temp->second->mUserData;
 735         if(!callback && !GlobalContextManager::getInstance()->isAliveGlobalContext(callback->getContext())) {
 736             mConnReqMap.erase(temp);
 737         }
 738     }
 739 }
 740
 741 void BluetoothAdapter::unregisterUUID(std::string &uuid)
 742 {
 743     mRegisteredUUID.erase(mRegisteredUUID.find(uuid));
 744     if(mRegisteredUUID.size() == 0 && mConnReqMap.size() == 0 && mConnectedSocket.size() == 0) {
 745         bt_socket_unset_connection_state_changed_cb();
 746     }
 747 }
 748
 749 bool BluetoothAdapter::closeConnectedSocket(int socket)
 750 {
 751     if(mEnabled == true) {
 752         ConnectedSocketMapT::iterator iter = mConnectedSocket.find(socket);
 753         if(iter == mConnectedSocket.end()) {
 754             LoggerW("Already disconnected");
 755             return true;
 756         }
 757
 758         mConnectedSocket.erase(iter);
 759         if(mConnectedSocket.size() == 0) {
 760             bt_socket_unset_data_received_cb();
 761         }
 762
 763         if(mRegisteredUUID.size() == 0 && mConnReqMap.size() == 0 && mConnectedSocket.size() == 0) {
 764             bt_socket_unset_connection_state_changed_cb();
 765         }
 766
 767         return true;
 768     }
 769     else {
 770         LoggerE("Bluetooth is not powered");
 771         return false;
 772     }
 773 }
 774
 775 void BluetoothAdapter::removeConnReq(std::string &remoteAddress)
 776 {
 777     mConnReqMap.erase(remoteAddress);
 778
 779     if(mRegisteredUUID.size() == 0 && mConnReqMap.size() == 0 && mConnectedSocket.size() == 0) {
 780         if(bt_socket_unset_connection_state_changed_cb() != BT_ERROR_NONE) {
 781             LoggerW("Unsetting connection event callback failed");
 782         }
 783     }
 784 }
 785
 786 BluetoothAdapter* BluetoothAdapter::getInstance()
 787 {
 788     static BluetoothAdapter instance;
 789     return &instance;
 790 }
 791
 792 bool BluetoothAdapter::isValidAddress(std::string &address)
 793 {
 794     pcrecpp::RE re("(([0-9a-zA-Z]+):)+([0-9a-zA-Z]+)");
 795     std::string compareAddress = "00:12:47:08:9A:A6";
 796
 797     if (!re.FullMatch(address)) {
 798         LoggerE("Invalid address");
 799         return false;
 800     }
 801
 802     if (address.size() != compareAddress.size())
 803     {
 804         LoggerE("Invalid size");
 805         return false;
 806     }
 807
 808     return true;
 809 }
 810
 811 bool BluetoothAdapter::isValidUUID(std::string &uuid)
 812 {
 813     pcrecpp::RE re("(([0-9a-zA-Z]+)-)+([0-9a-zA-Z]+)");
 814     std::string compareUUID = "00001101-0000-1000-8000-00805F9B34FB";
 815
 816     if (!re.FullMatch(uuid))
 817     {
 818         LoggerE("Invalid UUID");
 819         return false;
 820     }
 821
 822     if (uuid.size() != compareUUID.size())
 823     {
 824         LoggerE("Invalid size");
 825         return false;
 826     }
 827
 828     return true;
 829 }
 830
 831 std::string BluetoothAdapter::getName() const
 832 {
 833     char* name = NULL;
 834     std::string str = "";
 835
 836     TIME_TRACER_ITEM_BEGIN("getName::bt_adapter_get_name", 1);
 837     if(bt_adapter_get_name(&name) == BT_ERROR_NONE) {
 838         TIME_TRACER_ITEM_END("getName::bt_adapter_get_name", 1);
 839         if (name != NULL)
 840         {
 841             str = name;
 842             free(name);
 843         }
 844     }
 845     else {
 846         TIME_TRACER_ITEM_END("getName::bt_adapter_get_name", 1);
 847         LoggerE("bt_adapter_get_name() failed");
 848     }
 849
 850     return str;
 851 }
 852
 853 void BluetoothAdapter::setName(std::string &name, MultiCallbackUserDataPtr userData)
 854 {
 855     if(mEnabled == true) {
 856         std::string adapterName = getName();
 857         if(adapterName == name) {   // in case of same name
 858             LoggerD("same name");
 859             BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
 860             return;
 861         }
 862
 863         if(mUserDataList[SET_NAME] == NULL) {
 864             mUserDataList[SET_NAME] = userData;
 865         } else {
 866             LoggerE("Already requested");
 867             UnknownException *error = new UnknownException("Already requested");
 868             BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 869             return;
 870         }
 871
 872         TIME_TRACER_ITEM_BEGIN("setName::bt_adapter_set_name", 1);
 873         int ret = bt_adapter_set_name(name.c_str());
 874         TIME_TRACER_ITEM_END("setName::bt_adapter_set_name", 1);
 875
 876         switch(ret) {
 877             case BT_ERROR_NONE:
 878             {
 879                 LoggerD("bt_adapter_set_name() succeeded");
 880                 mRequestedName = name;
 881                 return;
 882             }
 883             case BT_ERROR_INVALID_PARAMETER:
 884             {
 885                 LoggerE("Invalid value");
 886                 InvalidValuesException *error = new InvalidValuesException("Invalid value");
 887                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 888                 break;
 889             }
 890             default:
 891             {
 892                 LoggerE("Invalid value");
 893                 UnknownException *error = new UnknownException("Unknown exception");
 894                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 895             }
 896         }
 897
 898         //TIME_TRACER_ITEM_BEGIN("setName::bt_adapter_unset_name_changed_cb", 1);
 899         //bt_adapter_unset_name_changed_cb();
 900         //TIME_TRACER_ITEM_END("setName::bt_adapter_unset_name_changed_cb", 1);
 901         mUserDataList[SET_NAME].reset();
 902     } else {   // Not enabled
 903         LoggerE("Bluetooth device is turned off");
 904         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
 905         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 906     }
 907 }
 908
 909 std::string BluetoothAdapter::getAddress() const
 910 {
 911     char* address = NULL;
 912     std::string str = "";
 913
 914     if (bt_adapter_get_address(&address) == BT_ERROR_NONE) {
 915         if (address != NULL) {
 916             str = address;
 917             free(address);
 918         }
 919         else {
 920             LoggerW("address is NULL");
 921         }
 922     }
 923     else {
 924         LoggerE("bt_adapter_get_address() failed");
 925     }
 926
 927     return str;
 928 }
 929
 930 bool BluetoothAdapter::getPowered() const
 931 {
 932     return mEnabled;
 933 }
 934
 935 void BluetoothAdapter::setPowered(bool powered, MultiCallbackUserDataPtr userData)
 936 {
 937     TIME_TRACER_ITEM_BEGIN("setPowered::check current state", 1);
 938
 939     if(powered == mEnabled) {
 940         LoggerD("same state");
 941         BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
 942         return;
 943     }
 944
 945     if(mUserDataList[SET_POWERED] == NULL) {
 946         mUserDataList[SET_POWERED] = userData;
 947     } else {
 948         // Already requested
 949         LoggerE("Already requested");
 950         ServiceNotAvailableException *error = new ServiceNotAvailableException("Already requested");
 951         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 952         return;
 953     }
 954
 955     TIME_TRACER_ITEM_END("setPowered::check current state", 1);
 956
 957     mRequestedState = powered;
 958     if(powered == true) {
 959         TIME_TRACER_ITEM_BEGIN("setPowered::bt_adapter_enable", 1);
 960         int ret = bt_adapter_enable();
 961         TIME_TRACER_ITEM_END("setPowered::bt_adapter_enable", 1);
 962
 963         switch(ret) {
 964             case BT_ERROR_NONE:
 965             {
 966                 LoggerD("bt_adapter_enable() succeeded");
 967                 return;
 968             }
 969             case BT_ERROR_ALREADY_DONE:
 970             {
 971                 // call successCallback
 972                 LoggerD("BT_ERROR_ALREADY_DONE");
 973                 BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
 974                 break;
 975             }
 976             case BT_ERROR_NOW_IN_PROGRESS:
 977             {
 978                 LoggerD("BT_ERROR_NOW_IN_PROGRESS");
 979                 ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is busy");
 980                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 981                 break;
 982             }
 983             default:
 984             {
 985                 LoggerD("Unknown error");
 986                 UnknownException *error = new UnknownException("Unknown error");
 987                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
 988             }
 989         }
 990     } else {
 991         TIME_TRACER_ITEM_BEGIN("setPowered::bt_adapter_disable", 1);
 992         int ret = bt_adapter_disable();
 993         TIME_TRACER_ITEM_END("setPowered::bt_adapter_disable", 1);
 994
 995         switch(ret) {
 996             case BT_ERROR_NONE:
 997             {
 998                 LoggerD("bt_adapter_disable() succeeded");
 999                 return;
1000             }
1001             case BT_ERROR_NOT_ENABLED:
1002             {
1003                 // call successCallback
1004                 LoggerD("Already disabled");
1005                 BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
1006                 break;
1007             }
1008             case BT_ERROR_NOW_IN_PROGRESS:
1009             {
1010                 LoggerD("BT_ERROR_NOW_IN_PROGRESS");
1011                 ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is busy");
1012                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1013                 break;
1014             }
1015             default:
1016             {
1017                 LoggerD("Unknown error");
1018                 UnknownException *error = new UnknownException("Unknown error");
1019                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1020             }
1021         }
1022     }
1023
1024     mUserDataList[SET_POWERED].reset();
1025 }
1026
1027 bool BluetoothAdapter::getVisible() const
1028 {
1029     bt_adapter_visibility_mode_e mode;
1030
1031     if (bt_adapter_get_visibility(&mode, NULL) == BT_ERROR_NONE) {
1032         if (mode != BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) {
1033             return true;
1034         }
1035     }
1036
1037     return false;
1038 }
1039
1040 void BluetoothAdapter::setVisible(bool visible, unsigned int timeout, MultiCallbackUserDataPtr userData)
1041 {
1042     if(mEnabled == true) {
1043         bt_adapter_visibility_mode_e discoverable_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
1044         if(visible == true) {
1045             if(timeout == 0)
1046                 discoverable_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
1047             else
1048                 discoverable_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
1049         }
1050
1051         bt_adapter_visibility_mode_e current = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
1052         int time = 0;
1053
1054         TIME_TRACER_ITEM_BEGIN("setVisible::bt_adapter_get_visibility", 1);
1055         if(bt_adapter_get_visibility(&current , &time) != BT_ERROR_NONE) {
1056             LoggerE("bt_adapter_get_visibility() failed");
1057             UnknownException *error = new UnknownException("Can't get current visibility");
1058             BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1059             return;
1060         }
1061         TIME_TRACER_ITEM_END("setVisible::bt_adapter_get_visibility", 1);
1062
1063         if(discoverable_mode == current) {
1064             if(discoverable_mode != BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE) {
1065                 LoggerD("same visibility");
1066                 BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
1067                 return;
1068             }
1069             else if((unsigned int)time == timeout) {
1070                 LoggerD("same visibility");
1071                 BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
1072                 return;
1073             }
1074         }
1075
1076         if(mUserDataList[SET_VISIBLE] == NULL) {
1077             mUserDataList[SET_VISIBLE] = userData;
1078         } else {
1079             UnknownException *error = new UnknownException("Already requested");
1080             BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1081             return;
1082         }
1083
1084         mRequestedVisibility = discoverable_mode;
1085         TIME_TRACER_ITEM_BEGIN("setVisible::bt_adapter_set_visibility", 1);
1086         int ret = bt_adapter_set_visibility(discoverable_mode, timeout);
1087         TIME_TRACER_ITEM_END("setVisible::bt_adapter_set_visibility", 1);
1088         switch(ret) {
1089             case BT_ERROR_NONE:
1090             {
1091                 LoggerD("bt_adapter_set_visibility() succeeded");
1092                 return;
1093             }
1094             case BT_ERROR_INVALID_PARAMETER:
1095             {
1096                 InvalidValuesException *error = new InvalidValuesException("Invalid value");
1097                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1098                 break;
1099             }
1100             default:
1101             {
1102                 UnknownException *error = new UnknownException("Unknown error");
1103                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1104             }
1105         }
1106
1107         /*
1108         TIME_TRACER_ITEM_BEGIN("setVisible::bt_adapter_unset_visibility_mode_changed_cb", 1);
1109         bt_adapter_unset_visibility_mode_changed_cb();
1110         TIME_TRACER_ITEM_END("setVisible::bt_adapter_unset_visibility_mode_changed_cb", 1);
1111         */
1112         mUserDataList[SET_VISIBLE].reset();
1113     } else {   // Not enabled
1114         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
1115         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1116     }
1117
1118 }
1119
1120 void BluetoothAdapter::discoverDevices(MultiCallbackUserDataPtr userData)
1121 {
1122     TIME_TRACER_ITEM_BEGIN("discoverDevices::current state", 1);
1123
1124     if(mUserDataList[DISCOVER_DEVICES] == NULL) {
1125         mUserDataList[DISCOVER_DEVICES] = userData;
1126
1127         /*
1128         if(mUserDataList[STOP_DISCOVERY] == NULL)
1129             bt_adapter_set_device_discovery_state_changed_cb(onDiscoveryStateChangedCB, this);
1130         */
1131     } else {
1132         LoggerE("Already requested");
1133         UnknownException *error = new UnknownException("Already requested");
1134         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1135         return;
1136     }
1137
1138     TIME_TRACER_ITEM_END("discoverDevices::current state", 1);
1139
1140     if(mEnabled == true) {
1141         TIME_TRACER_ITEM_BEGIN("discoverDevices::bt_adapter_start_device_discovery", 1);
1142         int ret = bt_adapter_start_device_discovery();
1143         TIME_TRACER_ITEM_END("discoverDevices::bt_adapter_start_device_discovery", 1);
1144         switch(ret) {
1145             case BT_ERROR_NONE:
1146             {
1147                 LoggerD("bt_adapter_start_device_discovery() succeeded");
1148                 return;
1149             }
1150             default:
1151             {
1152                 LoggerE("Unknown exception");
1153                 UnknownException *error = new UnknownException("Unknown error");
1154                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1155             }
1156         }
1157     } else {   // Not enabled
1158         LoggerE("Bluetooth device is turned off");
1159         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
1160         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1161     }
1162
1163     mUserDataList[DISCOVER_DEVICES].reset();
1164     /*
1165     if(mUserDataList[STOP_DISCOVERY] == NULL) {
1166         bt_adapter_unset_device_discovery_state_changed_cb();
1167     }
1168     */
1169 }
1170
1171 void BluetoothAdapter::stopDiscovery(MultiCallbackUserDataPtr userData)
1172 {
1173     if(mEnabled == true) {
1174
1175         bool isDiscovering = false;
1176         bt_adapter_is_discovering(&isDiscovering);
1177         if(!isDiscovering) {
1178             BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
1179             return;
1180         }
1181
1182         if(mUserDataList[STOP_DISCOVERY] == NULL) {
1183             mUserDataList[STOP_DISCOVERY] = userData;
1184
1185             /*
1186             if(mUserDataList[DISCOVER_DEVICES] == NULL)
1187                 bt_adapter_set_device_discovery_state_changed_cb(onDiscoveryStateChangedCB, this);
1188             */
1189         } else {
1190             LoggerD("Already requested");
1191             UnknownException *error = new UnknownException("Already requested");
1192             BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1193             return;
1194         }
1195
1196         TIME_TRACER_ITEM_BEGIN("stopDiscovery::bt_adapter_stop_device_discovery", 1);
1197         int ret = bt_adapter_stop_device_discovery();
1198         TIME_TRACER_ITEM_END("stopDiscovery::bt_adapter_stop_device_discovery", 1);
1199         switch(ret) {
1200             case BT_ERROR_NONE:
1201             {
1202                 LoggerD("bt_adapter_stop_device_discovery() succeeded");
1203                 return;
1204             }
1205             default:
1206             {
1207                 UnknownException *error = new UnknownException("Unknown error");
1208                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1209             }
1210         }
1211
1212         mUserDataList[STOP_DISCOVERY].reset();
1213         /*
1214         if(mUserDataList[DISCOVER_DEVICES] == NULL) {
1215             bt_adapter_unset_device_discovery_state_changed_cb();
1216         }
1217         */
1218     } else {   // Not enabled
1219         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
1220         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1221     }
1222 }
1223
1224 void BluetoothAdapter::getKnownDevices(MultiCallbackUserDataPtr userData)
1225 {
1226     BluetoothCallbackUtil::syncToAsyncDeviceArrayCallback(userData);
1227 }
1228
1229 void BluetoothAdapter::getDevice(std::string &address, MultiCallbackUserDataPtr userData)
1230 {
1231     BluetoothCallbackUtil::syncToAsyncDeviceCallback(userData, address);
1232 }
1233
1234 void BluetoothAdapter::createBonding(std::string &address, MultiCallbackUserDataPtr userData)
1235 {
1236     if(!isValidAddress(address)) {
1237         LoggerE("Wrong address");
1238         NotFoundException *error = new NotFoundException("Wrong address");
1239         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1240         return;
1241     }
1242
1243     if(mUserDataList[CREATE_BONDING] == NULL) {
1244         TIME_TRACER_ITEM_BEGIN("createBonding::bt_device_set_bond_created_cb", 1);
1245         if(bt_device_set_bond_created_cb(onBondCreatedCB, this) != BT_ERROR_NONE) {
1246             LoggerW("bt_device_set_bond_created_cb() failed");
1247         }
1248         TIME_TRACER_ITEM_END("createBonding::bt_device_set_bond_created_cb", 1);
1249         mCreateBondingAddress = address;
1250         mUserDataList[CREATE_BONDING] = userData;
1251     } else {
1252         LoggerE("Already requested");
1253         UnknownException *error = new UnknownException("Already requested");
1254         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1255         return;
1256     }
1257
1258     if(mEnabled == true) {
1259         TIME_TRACER_ITEM_BEGIN("createBonding::bt_device_create_bond", 1);
1260         int ret = bt_device_create_bond(address.c_str());
1261         TIME_TRACER_ITEM_END("createBonding::bt_device_create_bond", 1);
1262
1263         switch(ret) {
1264             case BT_ERROR_NONE:
1265             {
1266                 LoggerD("bt_device_create_bond() succeeded");
1267                 return;
1268             }
1269             case BT_ERROR_INVALID_PARAMETER:
1270             {
1271                 LoggerE("Not found");
1272                 NotFoundException *error = new NotFoundException("Not found");
1273                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1274                 break;
1275             }
1276             default:
1277             {
1278                 LoggerE("Unknown exception");
1279                 UnknownException *error = new UnknownException("Unknown error");
1280                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1281             }
1282         }
1283     } else {   // Not enabled
1284         LoggerE("Bluetooth device is turned off");
1285         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
1286         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1287     }
1288
1289     TIME_TRACER_ITEM_BEGIN("createBonding::bt_device_unset_bond_created_cb", 1);
1290     bt_device_unset_bond_created_cb();
1291     TIME_TRACER_ITEM_END("createBonding::bt_device_unset_bond_created_cb", 1);
1292     mCreateBondingAddress.clear();
1293     mUserDataList[CREATE_BONDING].reset();
1294 }
1295
1296 void BluetoothAdapter::destroyBonding(std::string &address, MultiCallbackUserDataPtr userData)
1297 {
1298     if(!isValidAddress(address)) {
1299         LoggerE("Wrong address");
1300         NotFoundException *error = new NotFoundException("Wrong address");
1301         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1302         return;
1303     }
1304
1305     if(mUserDataList[DESTROY_BONDING] == NULL) {
1306         TIME_TRACER_ITEM_BEGIN("destroyBonding::bt_device_set_bond_destroyed_cb", 1);
1307         if(bt_device_set_bond_destroyed_cb(onBondDestroyedCB, this) != BT_ERROR_NONE) {
1308             LoggerW("bt_device_set_bond_destroyed_cb() failed");
1309         }
1310         TIME_TRACER_ITEM_END("destroyBonding::bt_device_set_bond_destroyed_cb", 1);
1311         mDestroyBondingAddress = address;
1312         mUserDataList[DESTROY_BONDING] = userData;
1313     } else {
1314         LoggerD("Already requested");
1315         UnknownException *error = new UnknownException("Already requested");
1316         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1317         return;
1318     }
1319
1320     if(mEnabled == true) {
1321         bt_device_info_s *deviceInfo = NULL;
1322         TIME_TRACER_ITEM_BEGIN("destroyBonding::bt_adapter_get_bonded_device_info", 1);
1323         if(bt_adapter_get_bonded_device_info(address.c_str(), &deviceInfo) != BT_ERROR_NONE || deviceInfo == NULL) {
1324             TIME_TRACER_ITEM_END("destroyBonding::bt_adapter_get_bonded_device_info", 1);
1325             LoggerD("There is no bonding");
1326             NotFoundException *error = new NotFoundException("Not found");
1327             BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1328         }
1329         else {
1330             TIME_TRACER_ITEM_END("destroyBonding::bt_adapter_get_bonded_device_info", 1);
1331             bt_adapter_free_device_info(deviceInfo);
1332             TIME_TRACER_ITEM_BEGIN("destroyBonding::bt_device_destroy_bond", 1);
1333             int ret = bt_device_destroy_bond(address.c_str());
1334             TIME_TRACER_ITEM_END("destroyBonding::bt_device_destroy_bond", 1);
1335
1336             switch(ret) {
1337                 case BT_ERROR_NONE:
1338                 {
1339                     LoggerD("bt_device_destroy_bond() succeeded");
1340                     return;
1341                 }
1342                 case BT_ERROR_INVALID_PARAMETER:
1343                 {
1344                     NotFoundException *error = new NotFoundException("Not found");
1345                     BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1346                     break;
1347                 }
1348                 default:
1349                 {
1350                     UnknownException *error = new UnknownException("Unknown error");
1351                     BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1352                 }
1353             }
1354         }
1355     } else {   // Not enabled
1356         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
1357         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1358     }
1359
1360     TIME_TRACER_ITEM_BEGIN("destroyBonding::bt_device_unset_bond_destroyed_cb", 1);
1361     bt_device_unset_bond_destroyed_cb();
1362     TIME_TRACER_ITEM_END("destroyBonding::bt_device_unset_bond_destroyed_cb", 1);
1363
1364     mDestroyBondingAddress.clear();
1365     mUserDataList[DESTROY_BONDING].reset();
1366 }
1367
1368 void BluetoothAdapter::registerRFCOMMServiceByUUID(std::string &uuid, std::string &name, MultiCallbackUserDataPtr userData)
1369 {
1370     BluetoothCallbackUtil::syncToAsyncServiceCallback(userData, uuid, name);
1371 }
1372
1373 void BluetoothAdapter::connectToServiceByUUID(std::string &remoteAddress, std::string &uuid, Common::MultiCallbackUserDataPtr userData)
1374 {
1375     if(!isValidUUID(uuid)) {
1376         LoggerE("Wrong UUID");
1377         InvalidValuesException *error = new InvalidValuesException("Wrong UUID");
1378         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1379         return;
1380     }
1381
1382
1383     if(mEnabled == true) {
1384         TIME_TRACER_ITEM_BEGIN("connectToServiceByUUID::bt_socket_connect_rfcomm", 1);
1385         int ret = bt_socket_connect_rfcomm(remoteAddress.c_str(), uuid.c_str());
1386         TIME_TRACER_ITEM_END("connectToServiceByUUID::bt_socket_connect_rfcomm", 1);
1387
1388         switch(ret) {
1389             case BT_ERROR_NONE:
1390             {
1391                 LoggerD("bt_socket_connect_rfcomm() succeeded");
1392                 TIME_TRACER_ITEM_BEGIN("connectToServiceByUUID::bt_socket_set_connection_state_changed_cb", 1);
1393                 bt_socket_set_connection_state_changed_cb(onSocketConnected, this);
1394                 TIME_TRACER_ITEM_END("connectToServiceByUUID::bt_socket_set_connection_state_changed_cb", 1);
1395
1396                 BluetoothConnReqPtr connReq = new BluetoothConnReq(uuid, userData);
1397                 mConnReqMap.insert(std::pair<std::string, BluetoothConnReqPtr>(remoteAddress, connReq));
1398                 break;
1399             }
1400             case BT_ERROR_INVALID_PARAMETER:
1401             case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
1402             {
1403                 InvalidValuesException *error = new InvalidValuesException("Invalid value");
1404                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1405                 break;
1406             }
1407             default:
1408             {
1409                 UnknownException *error = new UnknownException("Unknown error");
1410                 BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1411             }
1412         }
1413     } else {   // Not enabled
1414         ServiceNotAvailableException *error =  new ServiceNotAvailableException("Bluetooth device is turned off");
1415         BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
1416     }
1417 }
1418
1419 void BluetoothAdapter::returnKnownDevices(Common::MultiCallbackUserDataPtr userData)
1420 {
1421     if(mEnabled == true) {
1422         knownDevices = mFoundDevices;
1423         if(bt_adapter_foreach_bonded_device(foreachBondedDevicesCB, this) == BT_ERROR_NONE) {
1424             if(knownDevices.size() > 0) { // There are found devices
1425
1426                 int num = knownDevices.size();
1427                 LoggerD("There are found devices " << num);
1428                 JSObjectRef devices[num];
1429                 for(int i = 0; i < num; i++) {
1430                     JSObjectRef deviceObj = JSBluetoothDevice::createJSObject(userData->getContext(), knownDevices[i]);
1431                     devices[i] = deviceObj;
1432                 }
1433
1434                 userData->invokeCallback("success", JSObjectMakeArray(userData->getContext(), num, devices, NULL));
1435             }
1436             else {  // There is no found device
1437                 userData->invokeCallback("success", JSObjectMakeArray(userData->getContext(), 0, NULL, NULL) );
1438             }
1439         }
1440         else {
1441             LoggerE("Unknown exception");
1442             userData->invokeCallback(
1443                     "error",
1444                     JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), UnknownException("Unknown exception"))
1445             );
1446         }
1447     } else {   // Not enabled
1448         LoggerE("Bluetooth device is turned off");
1449         userData->invokeCallback(
1450                 "error",
1451                 JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
1452         );
1453     }
1454 }
1455
1456 void BluetoothAdapter::returnDevice(std::string &address, Common::MultiCallbackUserDataPtr userData)
1457 {
1458     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1459
1460     if(!isValidAddress(address)) {
1461         LoggerE("Wrong address");
1462         userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), NotFoundException("Wrong address")));
1463         return;
1464     }
1465
1466     if(mEnabled == true) {
1467         bt_device_info_s *deviceInfo = NULL;
1468
1469         TIME_TRACER_ITEM_BEGIN("returnDevice::bt_adapter_get_bonded_device_info", 1);
1470         if(bt_adapter_get_bonded_device_info(address.c_str(), &deviceInfo) == BT_ERROR_NONE &&
1471                 deviceInfo != NULL) {
1472             TIME_TRACER_ITEM_END("returnDevice::bt_adapter_get_bonded_device_info", 1);
1473             BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
1474                         device->copyAceCheckAccessFunction(getInstance());
1475             bt_adapter_free_device_info(deviceInfo);
1476
1477             LoggerD("invoke successCallback");
1478             userData->invokeCallback("success", JSBluetoothDevice::createJSObject(userData->getContext(), device));
1479             TIME_TRACER_ITEM_END("returnDevice::bt_adapter_get_bonded_device_info", 1);
1480             return;
1481         }
1482
1483         std::vector<BluetoothDeviceSharedPtr>::iterator iter;
1484         for(iter = mFoundDevices.begin(); iter != mFoundDevices.end(); ++iter) {
1485                 BluetoothDeviceSharedPtr foundDevice = *iter;
1486             if(!strcmp(foundDevice->getAddress().c_str(), address.c_str())) {
1487                 LoggerD("Found in mFoundDevices");
1488                 userData->invokeCallback("success", JSBluetoothDevice::createJSObject(userData->getContext(), foundDevice));
1489                 break;
1490             }
1491         }
1492
1493         if(iter == mFoundDevices.end()) {
1494             LoggerE("Can't find this device");
1495
1496             userData->invokeCallback(
1497                     "error",
1498                     JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), NotFoundException("There is no device with the given address"))
1499             );
1500         }
1501
1502     } else {   // Not enabled
1503         LoggerE("Bluetooth device is turned off");
1504         userData->invokeCallback(
1505                 "error",
1506                 JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
1507         );
1508     }
1509
1510     TIME_TRACER_ITEM_END(__FUNCTION__, 1);
1511 }
1512
1513 void BluetoothAdapter::returnRegisteredService(std::string &uuid, std::string &name, Common::MultiCallbackUserDataPtr userData)
1514 {
1515     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1516
1517     if(!isValidUUID(uuid)) {
1518         LoggerE("Wrong UUID");
1519         userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Wrong UUID")));
1520         return;
1521     }
1522
1523     if(mEnabled == true) {
1524
1525         bool isRegistered;
1526         TIME_TRACER_ITEM_BEGIN("returnRegisteredService::bt_adapter_is_service_used", 1);
1527         if(bt_adapter_is_service_used(uuid.c_str(), &isRegistered) == BT_ERROR_NONE && isRegistered == true) {
1528             TIME_TRACER_ITEM_END("returnRegisteredService::bt_adapter_is_service_used", 1);
1529             LoggerD("Already registered");
1530             userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Already registered")));
1531             return;
1532         }
1533         TIME_TRACER_ITEM_END("returnRegisteredService::bt_adapter_is_service_used", 1);
1534
1535         int socket = -1;
1536         TIME_TRACER_ITEM_BEGIN("returnRegisteredService::bt_socket_create_rfcomm", 1);
1537         int ret = bt_socket_create_rfcomm(uuid.c_str(), &socket);
1538         TIME_TRACER_ITEM_END("returnRegisteredService::bt_socket_create_rfcomm", 1);
1539
1540         switch(ret) {
1541             case BT_ERROR_NONE:
1542             {
1543                 LoggerD("bt_socket_create_rfcomm() succeeded");
1544                 TIME_TRACER_ITEM_BEGIN("returnRegisteredService::bt_socket_listen_and_accept_rfcomm", 1);
1545                 int ret = bt_socket_listen_and_accept_rfcomm(socket, 0);
1546                 TIME_TRACER_ITEM_END("returnRegisteredService::bt_socket_listen_and_accept_rfcomm", 1);
1547                 switch(ret) {
1548                     case BT_ERROR_NONE:
1549                     {
1550                         LoggerD("bt_socket_listen() succeeded");
1551                         bt_socket_set_connection_state_changed_cb(onSocketConnected, this);
1552
1553                         BluetoothServiceHandlerPtr serviceHandler = new BluetoothServiceHandler(uuid, name, socket);
1554                                                 serviceHandler->copyAceCheckAccessFunction(getInstance());
1555                         mRegisteredUUID.insert(std::pair<std::string, BluetoothServiceHandlerPtr>(uuid, serviceHandler));
1556
1557                         JSObjectRef serviceObj = JSBluetoothServiceHandler::createJSObject(userData->getContext(), serviceHandler);
1558                         userData->invokeCallback("success", serviceObj);
1559                         break;
1560                     }
1561                     case BT_ERROR_INVALID_PARAMETER:
1562                     {
1563                         LoggerD("Invalid value");
1564                         userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Invalid value")));
1565                         break;
1566                     }
1567                     default:
1568                     {
1569                         LoggerD("Unknown exception");
1570                         userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), UnknownException("Unknown exception")));
1571                     }
1572                 }
1573
1574                 break;
1575             }
1576             case BT_ERROR_INVALID_PARAMETER:
1577             {
1578                 LoggerD("Invalid value");
1579                 userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), InvalidValuesException("Invalid value")));
1580                 break;
1581             }
1582             default:
1583             {
1584                 LoggerD("Unknown exception");
1585                 userData->invokeCallback("error", JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), UnknownException("Unknown exception")));
1586             }
1587         }
1588     } else {   // Not enabled
1589         LoggerE("Bluetooth device is turned off");
1590         userData->invokeCallback(
1591                 "error",
1592                 JSWebAPIErrorFactory::makeErrorObject(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
1593         );
1594     }
1595
1596     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1597 }
1598
1599 void BluetoothAdapter::setChangeListener(MultiCallbackUserDataPtr userData)
1600 {
1601     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1602
1603     LoggerD("Enter");
1604     mChangeListener = userData;
1605
1606     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1607 }
1608
1609 void BluetoothAdapter::unsetChangeListener()
1610 {
1611     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1612
1613     LoggerD("Enter");
1614     mChangeListener.reset();
1615
1616     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 1);
1617 }
1618
1619
1620
1621
1622
1623 } // Bluetooth
1624 } // DeviceAPI