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 void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
 551                 int num_properties, bt_property_t *properties)
 552 {
 553         oal_event_t event;
 554         gpointer event_data = NULL;
 555         remote_device_t *dev_info;
 556         ble_adv_data_t adv_info;
 557         gsize size = 0;
 558         bdstr_t bdstr;
 559
 560         BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr),
 561                         status, num_properties);
 562
 563         dev_info = g_new0(remote_device_t, 1);
 564         memcpy(dev_info->address.addr, bd_addr->address, 6);
 565         parse_device_properties(num_properties, properties, dev_info, &adv_info);
 566
 567         if (num_properties == 0) {
 568                 BT_ERR("!!Unexpected!! num properties is 0 status [%d]", status);
 569                 /* It is possible that app called get bonded device info for a device
 570                    which is not yet bonded or udner bonding, in such case, stack will return no properties.
 571                    It is also possible that after bonding is done, BT MW attempted to fetch
 572                    bonded device info, but due to internal stack error, 0 properties with status FAIL
 573                    are received from stack. In such cases, simply send the event to BT MW
 574                    and let it handle this event */
 575                 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
 576                 memcpy(&dev_props_event->device_info,
 577                                 dev_info, sizeof(remote_device_t));
 578                 event_data = dev_props_event;
 579                 event = OAL_EVENT_DEVICE_PROPERTIES;
 580                 size = sizeof(event_dev_properties_t);
 581         } else if (num_properties == 1) {
 582                 /* For one particular property a dedicated event to be sent */
 583                 switch (properties[0].type) {
 584                 case BT_PROPERTY_BDNAME:
 585                         event = OAL_EVENT_DEVICE_NAME;
 586                         event_data = dev_info;
 587                         send_event_trace(event, event_data, sizeof(remote_device_t),
 588                                 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
 589                         return;
 590                 case BT_PROPERTY_UUIDS: {
 591                         event_dev_services_t *services_info;
 592                         bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
 593                         BT_INFO("Properties len [%d] event structure size [%d]", properties[0].len, sizeof(event_dev_services_t));
 594
 595                         services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
 596                         services_info->address = dev_info->address;
 597                         memcpy(services_info->service_list, uuids, properties[0].len);
 598                         services_info->num = properties[0].len/sizeof(bt_uuid_t);
 599                         BT_INFO("Number of UUID [%d]", services_info->num);
 600                         event = OAL_EVENT_DEVICE_SERVICES;
 601                         event_data = services_info;
 602                         size = sizeof(event_dev_services_t) + properties[0].len;
 603                         g_free(dev_info);
 604                         break;
 605                 }
 606                 default:
 607                         BT_ERR("Single Property [%d] not handled", properties[0].type);
 608                         g_free(dev_info);
 609                         return;
 610                 }
 611         } else {
 612                 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
 613                 if (dev_info->type != DEV_TYPE_BREDR) {
 614                         int i;
 615
 616                         BT_INFO("BLE Device");
 617                         /* BLE Single or DUAL mode found, so it should have Adv data */
 618                         dev_props_event->adv_len = adv_info.len;
 619                         if (dev_props_event->adv_len > 0)
 620                                 memcpy(dev_props_event->adv_data,
 621                                         adv_info.adv_data, adv_info.len);
 622
 623                         for (i = 0; i < dev_props_event->adv_len; i++)
 624                                 BT_INFO("Adv Data[%d] = [0x%x]",
 625                                         i, dev_props_event->adv_data[i]);
 626                         memcpy(&dev_props_event->device_info,
 627                                 dev_info, sizeof(remote_device_t));
 628                 } else {
 629                         BT_INFO("BREDR type Device");
 630                         memcpy(&dev_props_event->device_info,
 631                                 dev_info, sizeof(remote_device_t));
 632                 }
 633
 634                 event_data = dev_props_event;
 635                 event = OAL_EVENT_DEVICE_PROPERTIES;
 636                 size = sizeof(event_dev_properties_t);
 637         }
 638
 639         send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
 640 }
 641
 642 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 643                 bt_bond_state_t state)
 644 {
 645         bt_address_t * address = g_new0(bt_address_t, 1);
 646         oal_event_t event;
 647         gsize size = 0;
 648
 649         BT_DBG("status: %d, state: %d", status, state);
 650
 651         memcpy(address->addr, bd_addr->address, 6);
 652
 653         switch (state) {
 654         case BT_BOND_STATE_BONDED:
 655                 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
 656                 break;
 657         case BT_BOND_STATE_NONE:
 658                 /* Reaches both when bonding removed or bonding cancelled */
 659                 if (BT_STATUS_SUCCESS != status) {
 660                         event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
 661                         bond_fail_info->status = convert_to_oal_status(status);
 662                         bond_fail_info->address = *address;
 663                         size = sizeof(event_dev_bond_failed_t);
 664                         send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
 665                         g_free(address);
 666                         return;
 667                 } else
 668                         event = OAL_EVENT_DEVICE_BONDING_REMOVED;
 669                 break;
 670         case BT_BOND_STATE_BONDING:
 671                 g_free(address);
 672                 return;
 673         default:
 674                 BT_ERR("Unexpected Bond state %d", state);
 675                 g_free(address);
 676                 return;
 677         }
 678         send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
 679 }
 680
 681 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 682                 bt_acl_state_t state)
 683 {
 684         event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
 685         //bt_address_t * address = g_new0(bt_address_t, 1);
 686         oal_event_t event;
 687         gsize size = 0;
 688
 689         BT_DBG("ACL State:%d, state: %d", status, state);
 690
 691         memcpy(conn_status->address.addr, bd_addr->address, 6);
 692
 693         if (BT_STATUS_SUCCESS != status) {
 694                 /* At present only timeout will cause non-success status, later we can add more */
 695                 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
 696                 BT_ERR("ACL State Error:%d, state: %d", status, state);
 697         } else
 698                 conn_status->status = OAL_STATUS_SUCCESS;
 699
 700         memcpy(conn_status->address.addr, bd_addr->address, 6);
 701         switch (state) {
 702         case BT_ACL_STATE_CONNECTED:
 703                 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
 704                 conn_status->status = OAL_STATUS_SUCCESS;
 705                 break;
 706         case BT_ACL_STATE_DISCONNECTED:
 707                 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
 708                 break;
 709         default:
 710                 BT_ERR("Unexpected ACL state %d", state);
 711                 g_free(conn_status);
 712                 return;
 713         }
 714
 715         size = sizeof(event_dev_conn_status_t);
 716         send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
 717 }
 718
 719 #ifdef TIZEN_BT_HAL
 720 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 721                 bt_le_conn_state_t state)
 722 {
 723         event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
 724         //bt_address_t * address = g_new0(bt_address_t, 1);
 725         oal_event_t event;
 726         gsize size = 0;
 727
 728         BT_DBG("LE conn status:%d, state: %d", status, state);
 729         memcpy(conn_status->address.addr, bd_addr->address, 6);
 730         if (BT_STATUS_SUCCESS != status)
 731                 /* At present only timeout will cause non-success status, later we can add more */
 732                 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
 733         else
 734                 conn_status->status = OAL_STATUS_SUCCESS;
 735
 736         switch (state) {
 737         case BT_LE_CONN_STATE_CONNECTED:
 738                 event = OAL_EVENT_DEVICE_LE_CONNECTED;
 739                 break;
 740         case BT_LE_CONN_STATE_DISCONNECTED:
 741                 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
 742                 break;
 743         default:
 744                 BT_ERR("Unexpected ACL state %d", state);
 745                 g_free(conn_status);
 746                 return;
 747         }
 748
 749         size = sizeof(event_dev_conn_status_t);
 750         send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
 751 }
 752 #endif
 753
 754 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
 755 {
 756         remote_device_t * dev_info = g_new0(remote_device_t, 1);
 757         gsize size = 0;
 758         BT_DBG("+");
 759
 760         memcpy(dev_info->address.addr, bd_addr->address, 6);
 761         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 762         dev_info->cod = device_class;
 763         size = sizeof(remote_device_t);
 764
 765         send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
 766 }
 767
 768 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
 769                 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
 770 {
 771         oal_event_t event;
 772         gpointer event_data = NULL;
 773         gsize size = 0;
 774         BT_DBG("+");
 775
 776         switch (pairing_variant) {
 777         case BT_SSP_VARIANT_PASSKEY_ENTRY:
 778         {
 779                 remote_device_t * dev_info = g_new0(remote_device_t, 1);
 780                 memcpy(dev_info->address.addr, bd_addr->address, 6);
 781                         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 782                 dev_info->cod = device_class;
 783                 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
 784                 event_data = dev_info;
 785                 size = sizeof(remote_device_t);
 786                 break;
 787         }
 788         case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
 789         {
 790                 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
 791
 792                 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
 793                         g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 794                 passkey_data->device_info.cod = device_class;
 795                 passkey_data->pass_key = pass_key;
 796                 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
 797                 event_data = passkey_data;
 798                 size = sizeof(event_dev_passkey_t);
 799                 break;
 800         }
 801         case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
 802         {
 803                 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
 804
 805                 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
 806                                 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 807                 passkey_data->device_info.cod = device_class;
 808                 passkey_data->pass_key = pass_key;
 809                 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
 810                 event_data = passkey_data;
 811                 size = sizeof(event_dev_passkey_t);
 812                 break;
 813         }
 814         case BT_SSP_VARIANT_CONSENT:
 815         {
 816                 remote_device_t * dev_info = g_new0(remote_device_t, 1);
 817
 818                 memcpy(dev_info->address.addr, bd_addr->address, 6);
 819                         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 820                 dev_info->cod = device_class;
 821                 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
 822                 event_data = dev_info;
 823                 size = sizeof(remote_device_t);
 824                 break;
 825         }
 826         default:
 827         {
 828                 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
 829                 return;
 830         }
 831         }
 832         send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
 833 }
 834
 835 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
 836 {
 837         event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
 838
 839         BT_INFO("service_d: %d", service_d);
 840         memcpy(auth_req->address.addr, bd_addr->address, 6);
 841         auth_req->service_id = service_d;
 842
 843         send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
 844 }
 845
 846 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
 847 {
 848         oal_event_t event;
 849         event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
 850
 851         if (trusted == BT_DEVICE_TRUSTED) {
 852                 BT_INFO("Device is Trusted");
 853                 event = OAL_EVENT_DEVICE_TRUSTED;
 854         } else {
 855                 BT_INFO("Device is Un Trusted");
 856                 event = OAL_EVENT_DEVICE_UNTRUSTED;
 857         }
 858         memcpy(trust_val->address.addr, bd_addr->address, 6);
 859         trust_val->status = OAL_STATUS_SUCCESS;
 860         send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
 861 }
 862
 863 #ifdef TIZEN_BT_HAL
 864 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid)
 865 {
 866         event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
 867
 868         memcpy(auth_req->address.addr, bd_addr->address, 6);
 869         memcpy(auth_req->uuid.uuid, uuid->uu, 16);
 870
 871         send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
 872 }
 873
 874 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
 875 {
 876         event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
 877
 878         BT_DBG("+");
 879
 880         memcpy(ev->address.addr, bd_addr->address, 6);
 881         ev->trust_val = trust_val;
 882         send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
 883                         ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
 884         BT_DBG("-");
 885 }
 886
 887 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
 888 {
 889         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 890         oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
 891
 892         BT_DBG("+");
 893
 894         memcpy(ev->address.addr, bd_addr->address, 6);
 895         ev->link_type = link_type;
 896         if (0 == state)
 897                 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
 898
 899         send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 900
 901         BT_DBG("-");
 902 }
 903
 904 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
 905 {
 906         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 907
 908         BT_DBG("+");
 909
 910         memcpy(ev->address.addr, bd_addr->address, 6);
 911         ev->link_type = link_type;
 912         ev->alert_type = alert_type;
 913         ev->rssi = rssi;
 914
 915         send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
 916                         ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 917         BT_DBG("-");
 918 }
 919
 920 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
 921 {
 922         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 923
 924         BT_DBG("+");
 925
 926         memcpy(ev->address.addr, bd_addr->address, 6);
 927         ev->link_type = link_type;
 928         ev->rssi = rssi;
 929
 930         send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
 931                         ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 932         BT_DBG("-");
 933 }
 934 #endif