bt-oal/oal-device-mgr.c

   1 /*
   2  * Open Adaptation Layer (OAL)
   3  *
   4  * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <dlog.h>
  22 #include <string.h>
  23
  24 #include <bluetooth.h>
  25
  26 #include "oal-event.h"
  27 #include "oal-internal.h"
  28 #include "oal-common.h"
  29 #include "oal-manager.h"
  30 #include "oal-utils.h"
  31 #include "oal-device-mgr.h"
  32
  33 static const bt_interface_t * blued_api;
  34
  35 void device_mgr_init(const bt_interface_t * stack_if)
  36 {
  37         blued_api = stack_if;
  38 }
  39
  40 void device_mgr_cleanup(void)
  41 {
  42         BT_DBG();
  43         blued_api = NULL;
  44 }
  45
  46 oal_status_t device_query_attributes(bt_address_t *addr)
  47 {
  48         int res;
  49         bdstr_t bdstr;
  50
  51         CHECK_OAL_INITIALIZED();
  52
  53         OAL_CHECK_PARAMETER(addr, return);
  54
  55         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
  56
  57         res = blued_api->get_remote_device_properties((bt_bdaddr_t *)addr);
  58         if (res != BT_STATUS_SUCCESS) {
  59                 BT_ERR("get_remote_device_properties error: [%s]", status2string(res));
  60                 return convert_to_oal_status(res);
  61         }
  62
  63         return OAL_STATUS_SUCCESS;
  64 }
  65
  66 oal_status_t device_query_services(bt_address_t * addr)
  67 {
  68         int res;
  69         bdstr_t bdstr;
  70
  71         CHECK_OAL_INITIALIZED();
  72
  73         OAL_CHECK_PARAMETER(addr, return);
  74
  75         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
  76
  77         res = blued_api->get_remote_services((bt_bdaddr_t *)addr);
  78         if (res != BT_STATUS_SUCCESS) {
  79                 BT_ERR("get_remote_services error: [%s]", status2string(res));
  80                 return convert_to_oal_status(res);
  81         }
  82
  83         return OAL_STATUS_SUCCESS;
  84 }
  85
  86 oal_status_t device_stop_query_sevices(bt_address_t * addr)
  87 {
  88         CHECK_OAL_INITIALIZED();
  89
  90         OAL_CHECK_PARAMETER(addr, return);
  91
  92         API_TRACE("Stop SDP search");
  93         /* Currently no HAL Interface for Stopping Service Search */
  94         return BT_STATUS_UNSUPPORTED;
  95 }
  96
  97 oal_status_t device_set_alias(bt_address_t * addr, char * alias)
  98 {
  99         int res;
 100         bt_property_t prop;
 101         bdstr_t bdstr;
 102
 103         CHECK_OAL_INITIALIZED();
 104         OAL_CHECK_PARAMETER(addr, return);
 105         OAL_CHECK_PARAMETER(alias, return);
 106
 107         API_TRACE("%s ->Alias: %s", bdt_bd2str(addr, &bdstr), alias);
 108
 109         prop.type = BT_PROPERTY_REMOTE_FRIENDLY_NAME;
 110         prop.len = strlen(alias);
 111         prop.val = alias;
 112         res = blued_api->set_remote_device_property((bt_bdaddr_t*)addr, &prop);
 113         if (res != BT_STATUS_SUCCESS) {
 114                 BT_ERR("set_remote_device_property error: [%s]", status2string(res));
 115                 BT_ERR("Alias: %s", alias);
 116                 return convert_to_oal_status(res);
 117         }
 118
 119         return OAL_STATUS_SUCCESS;
 120 }
 121
 122 oal_status_t device_create_bond(bt_address_t *addr, connection_type_e transport)
 123 {
 124         int res;
 125         bdstr_t bdstr;
 126
 127         CHECK_OAL_INITIALIZED();
 128
 129         OAL_CHECK_PARAMETER(addr, return);
 130
 131         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 132
 133         res = blued_api->create_bond((bt_bdaddr_t *)addr, transport);
 134         if (res != BT_STATUS_SUCCESS) {
 135                 BT_ERR("create_bond error: [%s]", status2string(res));
 136                 return convert_to_oal_status(res);
 137         }
 138
 139         return OAL_STATUS_SUCCESS;
 140 }
 141
 142 oal_status_t device_destroy_bond(bt_address_t * addr)
 143 {
 144         int res;
 145         bdstr_t bdstr;
 146
 147         CHECK_OAL_INITIALIZED();
 148
 149         OAL_CHECK_PARAMETER(addr, return);
 150
 151         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 152
 153         res = blued_api->remove_bond((bt_bdaddr_t *)addr);
 154         if (res != BT_STATUS_SUCCESS) {
 155                 BT_ERR("remove_bond error: [%s]", status2string(res));
 156                 return convert_to_oal_status(res);
 157         }
 158
 159         return OAL_STATUS_SUCCESS;
 160 }
 161
 162 oal_status_t device_stop_bond(bt_address_t * addr)
 163 {
 164         int res;
 165         bdstr_t bdstr;
 166
 167         CHECK_OAL_INITIALIZED();
 168
 169         OAL_CHECK_PARAMETER(addr, return);
 170
 171         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 172
 173         res = blued_api->cancel_bond((bt_bdaddr_t *)addr);
 174         if (res != BT_STATUS_SUCCESS) {
 175                 BT_ERR("cancel_bond error: [%s]", status2string(res));
 176                 return convert_to_oal_status(res);
 177         }
 178
 179         return OAL_STATUS_SUCCESS;
 180 }
 181
 182 oal_status_t device_accept_pin_request(bt_address_t * addr, const char * pin)
 183 {
 184         int res;
 185         bdstr_t bdstr;
 186
 187         CHECK_OAL_INITIALIZED();
 188
 189         OAL_CHECK_PARAMETER(addr, return);
 190         OAL_CHECK_PARAMETER(pin, return);
 191
 192         API_TRACE("[%s] PIN: %s", bdt_bd2str(addr, &bdstr), pin);
 193
 194         res = blued_api->pin_reply((bt_bdaddr_t *)addr, TRUE, strlen(pin), (bt_pin_code_t *)pin);
 195         if (res != BT_STATUS_SUCCESS) {
 196                 BT_ERR("pin_reply error: [%s]", status2string(res));
 197                 BT_ERR("PIN: %s", pin);
 198                 return convert_to_oal_status(res);
 199         }
 200
 201         return OAL_STATUS_SUCCESS;
 202 }
 203
 204 oal_status_t device_reject_pin_request(bt_address_t * addr)
 205 {
 206         int res;
 207         bdstr_t bdstr;
 208
 209         CHECK_OAL_INITIALIZED();
 210
 211         OAL_CHECK_PARAMETER(addr, return);
 212
 213         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 214
 215         res = blued_api->pin_reply((bt_bdaddr_t *)addr, FALSE, 0, NULL);
 216         if (res != BT_STATUS_SUCCESS) {
 217                 BT_ERR("pin_reply error: [%s]", status2string(res));
 218                 return convert_to_oal_status(res);
 219         }
 220
 221         return OAL_STATUS_SUCCESS;
 222 }
 223
 224 oal_status_t device_accept_passkey_entry(bt_address_t * addr, uint32_t passkey)
 225 {
 226         int res;
 227         bdstr_t bdstr;
 228
 229         CHECK_OAL_INITIALIZED();
 230
 231         OAL_CHECK_PARAMETER(addr, return);
 232
 233         API_TRACE("[%s] Passkey: %d", bdt_bd2str(addr, &bdstr), passkey);
 234
 235         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, TRUE, passkey);
 236         if (res != BT_STATUS_SUCCESS) {
 237                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 238                 BT_ERR("Passkey: %d", passkey);
 239                 return convert_to_oal_status(res);
 240
 241         }
 242
 243         return OAL_STATUS_SUCCESS;
 244 }
 245
 246 oal_status_t device_reject_passkey_entry(bt_address_t * addr)
 247 {
 248         int res;
 249         bdstr_t bdstr;
 250
 251         CHECK_OAL_INITIALIZED();
 252
 253         OAL_CHECK_PARAMETER(addr, return);
 254
 255         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 256
 257         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, FALSE, 0);
 258         if (res != BT_STATUS_SUCCESS) {
 259                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 260                 return convert_to_oal_status(res);
 261         }
 262
 263         return OAL_STATUS_SUCCESS;
 264 }
 265
 266 oal_status_t device_reply_passkey_confirmation(bt_address_t * addr, int accept)
 267 {
 268         int res;
 269         bdstr_t bdstr;
 270
 271         CHECK_OAL_INITIALIZED();
 272
 273         OAL_CHECK_PARAMETER(addr, return);
 274
 275         API_TRACE("[%s] accept: %d", bdt_bd2str(addr, &bdstr), accept);
 276
 277         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_CONFIRMATION, accept, 0);
 278         if (res != BT_STATUS_SUCCESS) {
 279                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 280                 BT_ERR("%d", accept);
 281                 return convert_to_oal_status(res);
 282         }
 283
 284         return OAL_STATUS_SUCCESS;
 285
 286 }
 287
 288 oal_status_t device_reply_ssp_consent(bt_address_t * addr, int accept)
 289 {
 290         int res;
 291         bdstr_t bdstr;
 292
 293         CHECK_OAL_INITIALIZED();
 294
 295         OAL_CHECK_PARAMETER(addr, return);
 296
 297         API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), accept);
 298
 299         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_CONSENT, accept, 0);
 300         if (res != BT_STATUS_SUCCESS) {
 301                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 302                 BT_ERR("%d", accept);
 303                 return convert_to_oal_status(res);
 304         }
 305
 306         return OAL_STATUS_SUCCESS;
 307 }
 308
 309 oal_status_t device_reply_auth_request(bt_address_t * addr, oal_service_t service_type, int accept, int always)
 310 {
 311         int res;
 312         bdstr_t bdstr;
 313
 314         CHECK_OAL_INITIALIZED();
 315
 316         OAL_CHECK_PARAMETER(addr, return);
 317
 318         API_TRACE("[%s] Accept: %d, always: %d, service_type: %d", bdt_bd2str(addr, &bdstr), accept, always, service_type);
 319
 320         res = blued_api->authorize_response((bt_bdaddr_t *)addr, service_type, accept, always);
 321         if (res != BT_STATUS_SUCCESS) {
 322                 BT_ERR("authorize_response error: [%s]", status2string(res));
 323                 BT_ERR("Accept: [%d], always: [%d], service_type: [%d]", accept, always, service_type);
 324                 return convert_to_oal_status(res);
 325         }
 326
 327         return OAL_STATUS_SUCCESS;
 328 }
 329
 330 oal_status_t device_set_authorized(bt_address_t * addr, int authorize)
 331 {
 332         int res;
 333         bdstr_t bdstr;
 334
 335         CHECK_OAL_INITIALIZED();
 336
 337         OAL_CHECK_PARAMETER(addr, return);
 338
 339         API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), authorize);
 340
 341         res = blued_api->set_authorization((bt_bdaddr_t *)addr, authorize);
 342         if (res != BT_STATUS_SUCCESS) {
 343                 BT_ERR("set_authorization error: [%s]", status2string(res));
 344                 BT_ERR("%d", authorize);
 345                 return convert_to_oal_status(res);
 346         }
 347
 348         return OAL_STATUS_SUCCESS;
 349 }
 350
 351 gboolean device_get_acl_conn_state(bt_address_t * addr)
 352 {
 353         int res;
 354         bdstr_t bdstr;
 355
 356         CHECK_OAL_INITIALIZED();
 357         OAL_CHECK_PARAMETER(addr, return);
 358
 359         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 360
 361         res = blued_api->get_connection_state((bt_bdaddr_t *)addr);
 362         BT_ERR("get_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
 363
 364         return res;
 365 }
 366
 367 gboolean device_get_svc_conn_state(bt_address_t * addr, oal_service_t svc_id)
 368 {
 369         int res;
 370         bdstr_t bdstr;
 371
 372         CHECK_OAL_INITIALIZED();
 373         OAL_CHECK_PARAMETER(addr, return);
 374
 375         API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), svc_id);
 376
 377 #ifdef TIZEN_BT_HAL
 378         res = blued_api->get_service_connection_state((bt_bdaddr_t *)addr, svc_id);
 379 #else
 380         BT_ERR("Not supported");
 381         res = FALSE;
 382 #endif
 383         BT_ERR("get_service_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
 384
 385         return res;
 386 }
 387
 388 oal_status_t device_set_osp_server(oal_osp_server_type_e type, int enable)
 389 {
 390         int res;
 391         uint32_t server_type;
 392
 393         CHECK_OAL_INITIALIZED();
 394
 395         API_TRACE("type: %d", type);
 396
 397 #ifdef TIZEN_BT_HAL
 398         switch (type) {
 399         case OAL_OSP_SERVER_OBEX:
 400                 server_type = BT_OSP_SERVER_OBEX;
 401                 break;
 402         default:
 403                 BT_ERR("unknown type: %d", type);
 404                 return OAL_STATUS_INVALID_PARAM;
 405         }
 406
 407         res = blued_api->set_agent_osp_server(server_type, enable);
 408         if (res != BT_STATUS_SUCCESS) {
 409                 BT_ERR("set_agent_osp_server error: [%s]", status2string(res));
 410                 return convert_to_oal_status(res);
 411         }
 412
 413         return OAL_STATUS_SUCCESS;
 414 #else
 415         BT_ERR("Not supported");
 416         res = OAL_STATUS_NOT_SUPPORT;
 417         return res;
 418 #endif
 419 }
 420
 421 oal_status_t device_set_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, gboolean trust)
 422 {
 423         int res;
 424         bdstr_t bdstr;
 425
 426         CHECK_OAL_INITIALIZED();
 427
 428         OAL_CHECK_PARAMETER(addr, return);
 429
 430         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 431
 432 #ifdef TIZEN_BT_HAL
 433         res = blued_api->set_trusted_profile((bt_bdaddr_t *)addr, profile, (trust ? 1 : 0));
 434         if (res != BT_STATUS_SUCCESS) {
 435                 BT_ERR("set_trusted_profile error: [%s]", status2string(res));
 436                 return convert_to_oal_status(res);
 437         }
 438
 439         return OAL_STATUS_SUCCESS;
 440 #else
 441         BT_ERR("Not supported");
 442         res = OAL_STATUS_NOT_SUPPORT;
 443         return res;
 444 #endif
 445 }
 446
 447 oal_status_t device_get_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, unsigned int *trusted)
 448 {
 449         int res;
 450         bdstr_t bdstr;
 451
 452         CHECK_OAL_INITIALIZED();
 453
 454         OAL_CHECK_PARAMETER(addr, return);
 455
 456         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 457
 458 #ifdef TIZEN_BT_HAL
 459         res = blued_api->get_trusted_profile((bt_bdaddr_t *)addr, profile, trusted);
 460         if (res != BT_STATUS_SUCCESS) {
 461                 BT_ERR("get_trusted_profile error: [%s]", status2string(res));
 462                 return convert_to_oal_status(res);
 463         }
 464
 465         return OAL_STATUS_SUCCESS;
 466 #else
 467         BT_ERR("Not supported");
 468         res = OAL_STATUS_NOT_SUPPORT;
 469         return res;
 470 #endif
 471 }
 472
 473 oal_status_t device_enable_rssi_monitoring(bt_address_t *addr, unsigned int link_type,
 474                 int low_threshold, int in_range_threshold, int high_threshold)
 475 {
 476         int res;
 477         bdstr_t bdstr;
 478
 479         CHECK_OAL_INITIALIZED();
 480
 481         OAL_CHECK_PARAMETER(addr, return);
 482
 483         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 484
 485 #ifdef TIZEN_BT_HAL
 486         res = blued_api->enable_rssi_monitoring((bt_bdaddr_t *)addr, link_type,
 487                         low_threshold, in_range_threshold, high_threshold);
 488         if (res != BT_STATUS_SUCCESS) {
 489                 BT_ERR("enable_rssi_monitoring error: [%s]", status2string(res));
 490                 return convert_to_oal_status(res);
 491         }
 492
 493         return OAL_STATUS_SUCCESS;
 494 #else
 495         BT_ERR("Not supported");
 496         res = OAL_STATUS_NOT_SUPPORT;
 497         return res;
 498 #endif
 499 }
 500
 501 oal_status_t device_get_connected_link_rssi_strength(bt_address_t *addr, unsigned int link_type)
 502 {
 503         int res;
 504         bdstr_t bdstr;
 505
 506         CHECK_OAL_INITIALIZED();
 507
 508         OAL_CHECK_PARAMETER(addr, return);
 509
 510         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 511
 512 #ifdef TIZEN_BT_HAL
 513         res = blued_api->get_connected_link_rssi_strength((bt_bdaddr_t *)addr, link_type);
 514         if (res != BT_STATUS_SUCCESS) {
 515                 BT_ERR("get_connected_link_rssi_strength error: [%s]", status2string(res));
 516                 return convert_to_oal_status(res);
 517         }
 518
 519         return OAL_STATUS_SUCCESS;
 520 #else
 521         BT_ERR("Not supported");
 522         res = OAL_STATUS_NOT_SUPPORT;
 523         return res;
 524 #endif
 525 }
 526
 527 oal_status_t device_enable_gap_auth_notifications(oal_gap_auth_type_e type, gboolean enable)
 528 {
 529         int res;
 530
 531         CHECK_OAL_INITIALIZED();
 532
 533         API_TRACE("type: [%d], enable: %d", type, enable);
 534
 535 #ifdef TIZEN_BT_HAL
 536         res = blued_api->enable_gap_auth_notifications(type, (enable ? 1 : 0));
 537         if (res != BT_STATUS_SUCCESS) {
 538                 BT_ERR("enable_gap_auth_notifications error: [%s]", status2string(res));
 539                 return convert_to_oal_status(res);
 540         }
 541
 542         return OAL_STATUS_SUCCESS;
 543 #else
 544         BT_ERR("Not supported");
 545         res = OAL_STATUS_NOT_SUPPORT;
 546         return res;
 547 #endif
 548 }
 549
 550 oal_status_t device_disconnect(bt_address_t * addr)
 551 {
 552         int res;
 553         bdstr_t bdstr;
 554
 555         CHECK_OAL_INITIALIZED();
 556
 557         OAL_CHECK_PARAMETER(addr, return);
 558
 559         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 560
 561         res = blued_api->device_disconnect((bt_bdaddr_t *)addr);
 562         if (res != BT_STATUS_SUCCESS) {
 563                 BT_ERR("device_disconnect error: [%s]", status2string(res));
 564                 return convert_to_oal_status(res);
 565         }
 566
 567         return OAL_STATUS_SUCCESS;
 568 }
 569
 570 void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
 571                 int num_properties, bt_property_t *properties)
 572 {
 573         oal_event_t event;
 574         gpointer event_data = NULL;
 575         remote_device_t *dev_info;
 576         ble_adv_data_t adv_info;
 577         gsize size = 0;
 578         bdstr_t bdstr;
 579
 580         BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr),
 581                         status, num_properties);
 582
 583         dev_info = g_new0(remote_device_t, 1);
 584         memcpy(dev_info->address.addr, bd_addr->address, 6);
 585         parse_device_properties(num_properties, properties, dev_info, &adv_info);
 586
 587         if (num_properties == 0) {
 588                 BT_ERR("!!Unexpected!! num properties is 0 status [%d]", status);
 589                 /* It is possible that app called get bonded device info for a device
 590                    which is not yet bonded or udner bonding, in such case, stack will return no properties.
 591                    It is also possible that after bonding is done, BT MW attempted to fetch
 592                    bonded device info, but due to internal stack error, 0 properties with status FAIL
 593                    are received from stack. In such cases, simply send the event to BT MW
 594                    and let it handle this event */
 595                 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
 596                 memcpy(&dev_props_event->device_info,
 597                                 dev_info, sizeof(remote_device_t));
 598                 event_data = dev_props_event;
 599                 event = OAL_EVENT_DEVICE_PROPERTIES;
 600                 size = sizeof(event_dev_properties_t);
 601                 g_free(dev_info);
 602         } else if (num_properties == 1) {
 603                 /* For one particular property a dedicated event to be sent */
 604                 switch (properties[0].type) {
 605                 case BT_PROPERTY_BDNAME:
 606                         event = OAL_EVENT_DEVICE_NAME;
 607                         event_data = dev_info;
 608                         send_event_trace(event, event_data, sizeof(remote_device_t),
 609                                 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
 610                         return;
 611                 case BT_PROPERTY_UUIDS: {
 612                         event_dev_services_t *services_info;
 613                         bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
 614                         BT_INFO("Properties len [%d] event structure size [%zu]", properties[0].len, sizeof(event_dev_services_t));
 615
 616                         services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
 617                         services_info->address = dev_info->address;
 618                         memcpy(services_info->service_list, uuids, properties[0].len);
 619                         services_info->num = properties[0].len/sizeof(bt_uuid_t);
 620                         BT_INFO("Number of UUID [%d]", services_info->num);
 621                         event = OAL_EVENT_DEVICE_SERVICES;
 622                         event_data = services_info;
 623                         size = sizeof(event_dev_services_t) + properties[0].len;
 624                         g_free(dev_info);
 625                         break;
 626                 }
 627                 default:
 628                         BT_ERR("Single Property [%d] not handled", properties[0].type);
 629                         g_free(dev_info);
 630                         return;
 631                 }
 632         } else {
 633                 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
 634                 if (dev_info->type != DEV_TYPE_BREDR) {
 635                         int i;
 636
 637                         BT_INFO("BLE Device");
 638                         /* BLE Single or DUAL mode found, so it should have Adv data */
 639                         dev_props_event->adv_len = adv_info.len;
 640                         if (dev_props_event->adv_len > 0)
 641                                 memcpy(dev_props_event->adv_data,
 642                                         adv_info.adv_data, adv_info.len);
 643
 644                         for (i = 0; i < dev_props_event->adv_len; i++)
 645                                 BT_INFO("Adv Data[%d] = [0x%x]",
 646                                         i, dev_props_event->adv_data[i]);
 647                         memcpy(&dev_props_event->device_info,
 648                                 dev_info, sizeof(remote_device_t));
 649                 } else {
 650                         BT_INFO("BREDR type Device");
 651                         memcpy(&dev_props_event->device_info,
 652                                 dev_info, sizeof(remote_device_t));
 653                 }
 654
 655                 event_data = dev_props_event;
 656                 event = OAL_EVENT_DEVICE_PROPERTIES;
 657                 size = sizeof(event_dev_properties_t);
 658                 g_free(dev_info);
 659         }
 660
 661         send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
 662 }
 663
 664 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 665                 bt_bond_state_t state)
 666 {
 667         bt_address_t * address = g_new0(bt_address_t, 1);
 668         oal_event_t event;
 669         gsize size = 0;
 670
 671         BT_DBG("status: %d, state: %d", status, state);
 672
 673         memcpy(address->addr, bd_addr->address, 6);
 674
 675         switch (state) {
 676         case BT_BOND_STATE_BONDED:
 677                 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
 678                 break;
 679         case BT_BOND_STATE_NONE:
 680                 /* Reaches both when bonding removed or bonding cancelled */
 681                 if (BT_STATUS_SUCCESS != status) {
 682                         event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
 683                         bond_fail_info->status = convert_to_oal_status(status);
 684                         bond_fail_info->address = *address;
 685                         size = sizeof(event_dev_bond_failed_t);
 686                         send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
 687                         g_free(address);
 688                         return;
 689                 } else
 690                         event = OAL_EVENT_DEVICE_BONDING_REMOVED;
 691                 break;
 692         case BT_BOND_STATE_BONDING:
 693                 g_free(address);
 694                 return;
 695         default:
 696                 BT_ERR("Unexpected Bond state %d", state);
 697                 g_free(address);
 698                 return;
 699         }
 700         send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
 701 }
 702
 703 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 704                 bt_acl_state_t state)
 705 {
 706         event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
 707         //bt_address_t * address = g_new0(bt_address_t, 1);
 708         oal_event_t event;
 709         gsize size = 0;
 710
 711         BT_DBG("ACL State:%d, state: %d", status, state);
 712
 713         memcpy(conn_status->address.addr, bd_addr->address, 6);
 714
 715 #ifdef TIZEN_BT_HAL
 716         conn_status->status = convert_to_oal_status(status);
 717 #else
 718         if (BT_STATUS_SUCCESS != status) {
 719                 /* At present only timeout will cause non-success status, later we can add more */
 720                 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
 721                 BT_ERR("ACL State Error:%d, state: %d", status, state);
 722         } else
 723                 conn_status->status = OAL_STATUS_SUCCESS;
 724
 725         memcpy(conn_status->address.addr, bd_addr->address, 6);
 726 #endif
 727
 728         BT_INFO("ACL STATE :%d, conn_status->status :%d, BT_ACL_STATE: %d", status, conn_status->status, state);
 729
 730         switch (state) {
 731         case BT_ACL_STATE_CONNECTED:
 732                 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
 733                 conn_status->status = OAL_STATUS_SUCCESS;
 734                 break;
 735         case BT_ACL_STATE_DISCONNECTED:
 736                 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
 737                 break;
 738         default:
 739                 BT_ERR("Unexpected ACL state %d", state);
 740                 g_free(conn_status);
 741                 return;
 742         }
 743
 744         size = sizeof(event_dev_conn_status_t);
 745         send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
 746 }
 747
 748 #ifdef TIZEN_BT_HAL
 749 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 750                 bt_le_conn_state_t state)
 751 {
 752         event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
 753         //bt_address_t * address = g_new0(bt_address_t, 1);
 754         oal_event_t event;
 755         gsize size = 0;
 756
 757         BT_DBG("LE conn status:%d, state: %d", status, state);
 758         memcpy(conn_status->address.addr, bd_addr->address, 6);
 759         conn_status->status = convert_to_oal_status(status);
 760
 761         switch (state) {
 762         case BT_LE_CONN_STATE_CONNECTED:
 763                 event = OAL_EVENT_DEVICE_LE_CONNECTED;
 764                 break;
 765         case BT_LE_CONN_STATE_DISCONNECTED:
 766                 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
 767                 break;
 768         default:
 769                 BT_ERR("Unexpected ACL state %d", state);
 770                 g_free(conn_status);
 771                 return;
 772         }
 773
 774         size = sizeof(event_dev_conn_status_t);
 775         send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
 776 }
 777 #endif
 778
 779 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
 780 {
 781         remote_device_t * dev_info = g_new0(remote_device_t, 1);
 782         gsize size = 0;
 783         BT_DBG("+");
 784
 785         memcpy(dev_info->address.addr, bd_addr->address, 6);
 786         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 787         dev_info->cod = device_class;
 788         size = sizeof(remote_device_t);
 789
 790         send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
 791 }
 792
 793 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
 794                 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
 795 {
 796         oal_event_t event;
 797         gpointer event_data = NULL;
 798         gsize size = 0;
 799         BT_DBG("+");
 800
 801         switch (pairing_variant) {
 802         case BT_SSP_VARIANT_PASSKEY_ENTRY:
 803         {
 804                 remote_device_t * dev_info = g_new0(remote_device_t, 1);
 805                 memcpy(dev_info->address.addr, bd_addr->address, 6);
 806                         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 807                 dev_info->cod = device_class;
 808                 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
 809                 event_data = dev_info;
 810                 size = sizeof(remote_device_t);
 811                 break;
 812         }
 813         case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
 814         {
 815                 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
 816
 817                 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
 818                         g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 819                 passkey_data->device_info.cod = device_class;
 820                 passkey_data->pass_key = pass_key;
 821                 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
 822                 event_data = passkey_data;
 823                 size = sizeof(event_dev_passkey_t);
 824                 break;
 825         }
 826         case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
 827         {
 828                 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
 829
 830                 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
 831                                 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 832                 passkey_data->device_info.cod = device_class;
 833                 passkey_data->pass_key = pass_key;
 834                 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
 835                 event_data = passkey_data;
 836                 size = sizeof(event_dev_passkey_t);
 837                 break;
 838         }
 839         case BT_SSP_VARIANT_CONSENT:
 840         {
 841                 remote_device_t * dev_info = g_new0(remote_device_t, 1);
 842
 843                 memcpy(dev_info->address.addr, bd_addr->address, 6);
 844                         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 845                 dev_info->cod = device_class;
 846                 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
 847                 event_data = dev_info;
 848                 size = sizeof(remote_device_t);
 849                 break;
 850         }
 851         default:
 852         {
 853                 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
 854                 return;
 855         }
 856         }
 857         send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
 858 }
 859
 860 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
 861 {
 862         event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
 863
 864         BT_INFO("service_d: %d", service_d);
 865         memcpy(auth_req->address.addr, bd_addr->address, 6);
 866         auth_req->service_id = service_d;
 867
 868         send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
 869 }
 870
 871 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
 872 {
 873         oal_event_t event;
 874         event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
 875
 876         if (trusted == BT_DEVICE_TRUSTED) {
 877                 BT_INFO("Device is Trusted");
 878                 event = OAL_EVENT_DEVICE_TRUSTED;
 879         } else {
 880                 BT_INFO("Device is Un Trusted");
 881                 event = OAL_EVENT_DEVICE_UNTRUSTED;
 882         }
 883         memcpy(trust_val->address.addr, bd_addr->address, 6);
 884         trust_val->status = OAL_STATUS_SUCCESS;
 885         send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
 886 }
 887
 888 #ifdef TIZEN_BT_HAL
 889 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid)
 890 {
 891         event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
 892
 893         memcpy(auth_req->address.addr, bd_addr->address, 6);
 894         memcpy(auth_req->uuid.uuid, uuid->uu, 16);
 895
 896         send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
 897 }
 898
 899 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
 900 {
 901         event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
 902
 903         BT_DBG("+");
 904
 905         memcpy(ev->address.addr, bd_addr->address, 6);
 906         ev->trust_val = trust_val;
 907         send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
 908                         ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
 909         BT_DBG("-");
 910 }
 911
 912 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
 913 {
 914         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 915         oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
 916
 917         BT_DBG("+");
 918
 919         memcpy(ev->address.addr, bd_addr->address, 6);
 920         ev->link_type = link_type;
 921         if (0 == state)
 922                 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
 923
 924         send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 925
 926         BT_DBG("-");
 927 }
 928
 929 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
 930 {
 931         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 932
 933         BT_DBG("+");
 934
 935         memcpy(ev->address.addr, bd_addr->address, 6);
 936         ev->link_type = link_type;
 937         ev->alert_type = alert_type;
 938         ev->rssi = rssi;
 939
 940         send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
 941                         ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 942         BT_DBG("-");
 943 }
 944
 945 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
 946 {
 947         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 948
 949         BT_DBG("+");
 950
 951         memcpy(ev->address.addr, bd_addr->address, 6);
 952         ev->link_type = link_type;
 953         ev->rssi = rssi;
 954
 955         send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
 956                         ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 957         BT_DBG("-");
 958 }
 959
 960 #endif