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, oal_conn_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_get_ida(bt_address_t *device_address, bt_address_t *id_address)
 183 {
 184         int res;
 185
 186         CHECK_OAL_INITIALIZED();
 187
 188         OAL_CHECK_PARAMETER(device_address, return);
 189
 190         API_TRACE();
 191
 192         res = blued_api->get_device_ida((bt_bdaddr_t*) device_address, (bt_bdaddr_t*) id_address);
 193
 194         if (res != BT_STATUS_SUCCESS)
 195                 BT_ERR("get_device_IDA failed: [%s]",status2string(res));
 196
 197         res = convert_to_oal_status(res);
 198         return res;
 199 }
 200
 201 oal_status_t device_accept_pin_request(bt_address_t * addr, const char * pin)
 202 {
 203         int res;
 204         bdstr_t bdstr;
 205
 206         CHECK_OAL_INITIALIZED();
 207
 208         OAL_CHECK_PARAMETER(addr, return);
 209         OAL_CHECK_PARAMETER(pin, return);
 210
 211         API_TRACE("[%s] PIN: %s", bdt_bd2str(addr, &bdstr), pin);
 212
 213         res = blued_api->pin_reply((bt_bdaddr_t *)addr, TRUE, strlen(pin), (bt_pin_code_t *)pin);
 214         if (res != BT_STATUS_SUCCESS) {
 215                 BT_ERR("pin_reply error: [%s]", status2string(res));
 216                 BT_ERR("PIN: %s", pin);
 217                 return convert_to_oal_status(res);
 218         }
 219
 220         return OAL_STATUS_SUCCESS;
 221 }
 222
 223 oal_status_t device_reject_pin_request(bt_address_t * addr)
 224 {
 225         int res;
 226         bdstr_t bdstr;
 227
 228         CHECK_OAL_INITIALIZED();
 229
 230         OAL_CHECK_PARAMETER(addr, return);
 231
 232         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 233
 234         res = blued_api->pin_reply((bt_bdaddr_t *)addr, FALSE, 0, NULL);
 235         if (res != BT_STATUS_SUCCESS) {
 236                 BT_ERR("pin_reply error: [%s]", status2string(res));
 237                 return convert_to_oal_status(res);
 238         }
 239
 240         return OAL_STATUS_SUCCESS;
 241 }
 242
 243 oal_status_t device_accept_passkey_entry(bt_address_t * addr, uint32_t passkey)
 244 {
 245         int res;
 246         bdstr_t bdstr;
 247
 248         CHECK_OAL_INITIALIZED();
 249
 250         OAL_CHECK_PARAMETER(addr, return);
 251
 252         API_TRACE("[%s] Passkey: %d", bdt_bd2str(addr, &bdstr), passkey);
 253
 254         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, TRUE, passkey);
 255         if (res != BT_STATUS_SUCCESS) {
 256                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 257                 BT_ERR("Passkey: %d", passkey);
 258                 return convert_to_oal_status(res);
 259
 260         }
 261
 262         return OAL_STATUS_SUCCESS;
 263 }
 264
 265 oal_status_t device_reject_passkey_entry(bt_address_t * addr)
 266 {
 267         int res;
 268         bdstr_t bdstr;
 269
 270         CHECK_OAL_INITIALIZED();
 271
 272         OAL_CHECK_PARAMETER(addr, return);
 273
 274         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 275
 276         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_ENTRY, FALSE, 0);
 277         if (res != BT_STATUS_SUCCESS) {
 278                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 279                 return convert_to_oal_status(res);
 280         }
 281
 282         return OAL_STATUS_SUCCESS;
 283 }
 284
 285 oal_status_t device_reply_passkey_confirmation(bt_address_t * addr, int accept)
 286 {
 287         int res;
 288         bdstr_t bdstr;
 289
 290         CHECK_OAL_INITIALIZED();
 291
 292         OAL_CHECK_PARAMETER(addr, return);
 293
 294         API_TRACE("[%s] accept: %d", bdt_bd2str(addr, &bdstr), accept);
 295
 296         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_PASSKEY_CONFIRMATION, accept, 0);
 297         if (res != BT_STATUS_SUCCESS) {
 298                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 299                 BT_ERR("%d", accept);
 300                 return convert_to_oal_status(res);
 301         }
 302
 303         return OAL_STATUS_SUCCESS;
 304
 305 }
 306
 307 oal_status_t device_reply_ssp_consent(bt_address_t * addr, int accept)
 308 {
 309         int res;
 310         bdstr_t bdstr;
 311
 312         CHECK_OAL_INITIALIZED();
 313
 314         OAL_CHECK_PARAMETER(addr, return);
 315
 316         API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), accept);
 317
 318         res = blued_api->ssp_reply((bt_bdaddr_t *)addr, BT_SSP_VARIANT_CONSENT, accept, 0);
 319         if (res != BT_STATUS_SUCCESS) {
 320                 BT_ERR("ssp_reply error: [%s]", status2string(res));
 321                 BT_ERR("%d", accept);
 322                 return convert_to_oal_status(res);
 323         }
 324
 325         return OAL_STATUS_SUCCESS;
 326 }
 327
 328 oal_status_t device_reply_auth_request(bt_address_t * addr, oal_service_t service_type, int accept, int always)
 329 {
 330         int res;
 331         bdstr_t bdstr;
 332
 333         CHECK_OAL_INITIALIZED();
 334
 335         OAL_CHECK_PARAMETER(addr, return);
 336
 337         API_TRACE("[%s] Accept: %d, always: %d, service_type: %d", bdt_bd2str(addr, &bdstr), accept, always, service_type);
 338
 339         res = blued_api->authorize_response((bt_bdaddr_t *)addr, service_type, accept, always);
 340         if (res != BT_STATUS_SUCCESS) {
 341                 BT_ERR("authorize_response error: [%s]", status2string(res));
 342                 BT_ERR("Accept: [%d], always: [%d], service_type: [%d]", accept, always, service_type);
 343                 return convert_to_oal_status(res);
 344         }
 345
 346         return OAL_STATUS_SUCCESS;
 347 }
 348
 349 oal_status_t device_set_authorized(bt_address_t * addr, int authorize)
 350 {
 351         int res;
 352         bdstr_t bdstr;
 353
 354         CHECK_OAL_INITIALIZED();
 355
 356         OAL_CHECK_PARAMETER(addr, return);
 357
 358         API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), authorize);
 359
 360         res = blued_api->set_authorization((bt_bdaddr_t *)addr, authorize);
 361         if (res != BT_STATUS_SUCCESS) {
 362                 BT_ERR("set_authorization error: [%s]", status2string(res));
 363                 BT_ERR("%d", authorize);
 364                 return convert_to_oal_status(res);
 365         }
 366
 367         return OAL_STATUS_SUCCESS;
 368 }
 369
 370 gboolean device_get_acl_conn_state(bt_address_t * addr)
 371 {
 372         int res;
 373         bdstr_t bdstr;
 374
 375         CHECK_OAL_INITIALIZED();
 376         OAL_CHECK_PARAMETER(addr, return);
 377
 378         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 379
 380         res = blued_api->get_connection_state((bt_bdaddr_t *)addr);
 381         BT_ERR("get_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
 382
 383         return res;
 384 }
 385
 386 gboolean device_get_svc_conn_state(bt_address_t * addr, oal_service_t svc_id)
 387 {
 388         int res;
 389         bdstr_t bdstr;
 390
 391         CHECK_OAL_INITIALIZED();
 392         OAL_CHECK_PARAMETER(addr, return);
 393
 394         API_TRACE("[%s] %d", bdt_bd2str(addr, &bdstr), svc_id);
 395
 396 #ifdef TIZEN_BT_HAL
 397         res = blued_api->get_service_connection_state((bt_bdaddr_t *)addr, svc_id);
 398 #else
 399         BT_ERR("Not supported");
 400         res = FALSE;
 401 #endif
 402         BT_ERR("get_service_connection_state returned: [%s]", res ? "TRUE" : "FALSE");
 403
 404         return res;
 405 }
 406
 407 oal_status_t device_register_osp_server(oal_osp_server_type_e type, char *uuid, char *path, int fd)
 408 {
 409         int res;
 410         uint32_t server_type;
 411
 412         CHECK_OAL_INITIALIZED();
 413
 414         API_TRACE("type: %d", type);
 415
 416 #ifdef TIZEN_BT_HAL
 417         switch (type) {
 418         case OAL_OSP_SERVER_OBEX:
 419                 server_type = BT_OSP_SERVER_OBEX;
 420                 break;
 421         case OAL_OSP_SERVER_RFCOMM:
 422                 server_type = BT_OSP_SERVER_RFCOMM;
 423                 break;
 424         default:
 425                 BT_ERR("unknown type: %d", type);
 426                 return OAL_STATUS_INVALID_PARAM;
 427         }
 428
 429         res = blued_api->register_agent_osp_server(server_type, uuid, path, fd);
 430         if (res != BT_STATUS_SUCCESS) {
 431                 BT_ERR("register_agent_osp_server error: [%s]", status2string(res));
 432                 return convert_to_oal_status(res);
 433         }
 434
 435         return OAL_STATUS_SUCCESS;
 436 #else
 437         BT_ERR("Not supported");
 438         res = OAL_STATUS_NOT_SUPPORT;
 439         return res;
 440 #endif
 441 }
 442
 443 oal_status_t device_unregister_osp_server(oal_osp_server_type_e type, char *uuid)
 444 {
 445         int res;
 446         uint32_t server_type;
 447
 448         CHECK_OAL_INITIALIZED();
 449
 450         API_TRACE("type: %d", type);
 451
 452 #ifdef TIZEN_BT_HAL
 453         switch (type) {
 454         case OAL_OSP_SERVER_OBEX:
 455                 server_type = BT_OSP_SERVER_OBEX;
 456                 break;
 457         case OAL_OSP_SERVER_RFCOMM:
 458                 server_type = BT_OSP_SERVER_RFCOMM;
 459                 break;
 460         default:
 461                 BT_ERR("unknown type: %d", type);
 462                 return OAL_STATUS_INVALID_PARAM;
 463         }
 464
 465         res = blued_api->unregister_agent_osp_server(server_type, uuid);
 466         if (res != BT_STATUS_SUCCESS) {
 467                 BT_ERR("unregister_agent_osp_server error: [%s]", status2string(res));
 468                 return convert_to_oal_status(res);
 469         }
 470
 471         return OAL_STATUS_SUCCESS;
 472 #else
 473         BT_ERR("Not supported");
 474         res = OAL_STATUS_NOT_SUPPORT;
 475         return res;
 476 #endif
 477 }
 478
 479 oal_status_t device_set_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, gboolean trust)
 480 {
 481         int res;
 482         bdstr_t bdstr;
 483
 484         CHECK_OAL_INITIALIZED();
 485
 486         OAL_CHECK_PARAMETER(addr, return);
 487
 488         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 489
 490 #ifdef TIZEN_BT_HAL
 491         res = blued_api->set_trusted_profile((bt_bdaddr_t *)addr, profile, (trust ? 1 : 0));
 492         if (res != BT_STATUS_SUCCESS) {
 493                 BT_ERR("set_trusted_profile error: [%s]", status2string(res));
 494                 return convert_to_oal_status(res);
 495         }
 496
 497         return OAL_STATUS_SUCCESS;
 498 #else
 499         BT_ERR("Not supported");
 500         res = OAL_STATUS_NOT_SUPPORT;
 501         return res;
 502 #endif
 503 }
 504
 505 oal_status_t device_get_trust_profile(bt_address_t *addr, oal_trusted_profile_e profile, unsigned int *trusted)
 506 {
 507         int res;
 508         bdstr_t bdstr;
 509
 510         CHECK_OAL_INITIALIZED();
 511
 512         OAL_CHECK_PARAMETER(addr, return);
 513
 514         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 515
 516 #ifdef TIZEN_BT_HAL
 517         res = blued_api->get_trusted_profile((bt_bdaddr_t *)addr, profile, trusted);
 518         if (res != BT_STATUS_SUCCESS) {
 519                 BT_ERR("get_trusted_profile error: [%s]", status2string(res));
 520                 return convert_to_oal_status(res);
 521         }
 522
 523         return OAL_STATUS_SUCCESS;
 524 #else
 525         BT_ERR("Not supported");
 526         res = OAL_STATUS_NOT_SUPPORT;
 527         return res;
 528 #endif
 529 }
 530
 531 oal_status_t device_enable_rssi_monitoring(bt_address_t *addr, unsigned int link_type,
 532                 int low_threshold, int in_range_threshold, int high_threshold)
 533 {
 534         int res;
 535         bdstr_t bdstr;
 536
 537         CHECK_OAL_INITIALIZED();
 538
 539         OAL_CHECK_PARAMETER(addr, return);
 540
 541         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 542
 543 #ifdef TIZEN_BT_HAL
 544         res = blued_api->enable_rssi_monitoring((bt_bdaddr_t *)addr, link_type,
 545                         low_threshold, in_range_threshold, high_threshold);
 546         if (res != BT_STATUS_SUCCESS) {
 547                 BT_ERR("enable_rssi_monitoring error: [%s]", status2string(res));
 548                 return convert_to_oal_status(res);
 549         }
 550
 551         return OAL_STATUS_SUCCESS;
 552 #else
 553         BT_ERR("Not supported");
 554         res = OAL_STATUS_NOT_SUPPORT;
 555         return res;
 556 #endif
 557 }
 558
 559 oal_status_t device_get_connected_link_rssi_strength(bt_address_t *addr, unsigned int link_type)
 560 {
 561         int res;
 562         bdstr_t bdstr;
 563
 564         CHECK_OAL_INITIALIZED();
 565
 566         OAL_CHECK_PARAMETER(addr, return);
 567
 568         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 569
 570 #ifdef TIZEN_BT_HAL
 571         res = blued_api->get_connected_link_rssi_strength((bt_bdaddr_t *)addr, link_type);
 572         if (res != BT_STATUS_SUCCESS) {
 573                 BT_ERR("get_connected_link_rssi_strength error: [%s]", status2string(res));
 574                 return convert_to_oal_status(res);
 575         }
 576
 577         return OAL_STATUS_SUCCESS;
 578 #else
 579         BT_ERR("Not supported");
 580         res = OAL_STATUS_NOT_SUPPORT;
 581         return res;
 582 #endif
 583 }
 584
 585 oal_status_t device_enable_gap_auth_notifications(oal_gap_auth_type_e type, gboolean enable)
 586 {
 587         int res;
 588
 589         CHECK_OAL_INITIALIZED();
 590
 591         API_TRACE("type: [%d], enable: %d", type, enable);
 592
 593 #ifdef TIZEN_BT_HAL
 594         res = blued_api->enable_gap_auth_notifications(type, (enable ? 1 : 0));
 595         if (res != BT_STATUS_SUCCESS) {
 596                 BT_ERR("enable_gap_auth_notifications error: [%s]", status2string(res));
 597                 return convert_to_oal_status(res);
 598         }
 599
 600         return OAL_STATUS_SUCCESS;
 601 #else
 602         BT_ERR("Not supported");
 603         res = OAL_STATUS_NOT_SUPPORT;
 604         return res;
 605 #endif
 606 }
 607
 608 oal_status_t device_disconnect(bt_address_t * addr)
 609 {
 610         int res;
 611         bdstr_t bdstr;
 612
 613         CHECK_OAL_INITIALIZED();
 614
 615         OAL_CHECK_PARAMETER(addr, return);
 616
 617         API_TRACE("[%s]", bdt_bd2str(addr, &bdstr));
 618
 619         res = blued_api->device_disconnect((bt_bdaddr_t *)addr);
 620         if (res != BT_STATUS_SUCCESS) {
 621                 BT_ERR("device_disconnect error: [%s]", status2string(res));
 622                 return convert_to_oal_status(res);
 623         }
 624
 625         return OAL_STATUS_SUCCESS;
 626 }
 627
 628 void cb_device_properties(bt_status_t status, bt_bdaddr_t *bd_addr,
 629                 int num_properties, bt_property_t *properties)
 630 {
 631         oal_event_t event;
 632         gpointer event_data = NULL;
 633         remote_device_t *dev_info;
 634         ble_adv_data_t adv_info;
 635         gsize size = 0;
 636         bdstr_t bdstr;
 637
 638         BT_DBG("[%s]status: [%d] num properties [%d]", bdt_bd2str((bt_address_t*)bd_addr, &bdstr),
 639                         status, num_properties);
 640
 641         dev_info = g_new0(remote_device_t, 1);
 642         memcpy(dev_info->address.addr, bd_addr->address, 6);
 643         parse_device_properties(num_properties, properties, dev_info, &adv_info);
 644
 645         if (num_properties == 0) {
 646                 BT_ERR("!!Unexpected!! num properties is 0 status [%d]", status);
 647                 /* It is possible that app called get bonded device info for a device
 648                    which is not yet bonded or udner bonding, in such case, stack will return no properties.
 649                    It is also possible that after bonding is done, BT MW attempted to fetch
 650                    bonded device info, but due to internal stack error, 0 properties with status FAIL
 651                    are received from stack. In such cases, simply send the event to BT MW
 652                    and let it handle this event */
 653                 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
 654                 memcpy(&dev_props_event->device_info,
 655                                 dev_info, sizeof(remote_device_t));
 656                 event_data = dev_props_event;
 657                 event = OAL_EVENT_DEVICE_PROPERTIES;
 658                 size = sizeof(event_dev_properties_t);
 659                 g_free(dev_info);
 660         } else if (num_properties == 1) {
 661                 /* For one particular property a dedicated event to be sent */
 662                 switch (properties[0].type) {
 663                 case BT_PROPERTY_BDNAME:
 664                         event = OAL_EVENT_DEVICE_NAME;
 665                         event_data = dev_info;
 666                         send_event_trace(event, event_data, sizeof(remote_device_t),
 667                                 (bt_address_t*)bd_addr, "Name: %s", dev_info->name);
 668                         return;
 669                 case BT_PROPERTY_UUIDS: {
 670                         event_dev_services_t *services_info;
 671                         bt_uuid_t *uuids = (bt_uuid_t *) properties[0].val;
 672                         BT_INFO("Properties len [%d] event structure size [%zu]", properties[0].len, sizeof(event_dev_services_t));
 673
 674                         services_info = g_malloc(sizeof(event_dev_services_t) + properties[0].len);
 675                         services_info->address = dev_info->address;
 676                         memcpy(services_info->service_list, uuids, properties[0].len);
 677                         services_info->num = properties[0].len/sizeof(bt_uuid_t);
 678                         BT_INFO("Number of UUID [%d]", services_info->num);
 679                         event = OAL_EVENT_DEVICE_SERVICES;
 680                         event_data = services_info;
 681                         size = sizeof(event_dev_services_t) + properties[0].len;
 682                         g_free(dev_info);
 683                         break;
 684                 }
 685                 default:
 686                         BT_ERR("Single Property [%d] not handled", properties[0].type);
 687                         g_free(dev_info);
 688                         return;
 689                 }
 690         } else {
 691                 event_dev_properties_t *dev_props_event = g_new0(event_dev_properties_t, 1);
 692                 if (dev_info->type != DEV_TYPE_BREDR) {
 693                         int i;
 694
 695                         BT_INFO("BLE Device");
 696                         /* BLE Single or DUAL mode found, so it should have Adv data */
 697                         dev_props_event->adv_len = adv_info.len;
 698                         if (dev_props_event->adv_len > 0)
 699                                 memcpy(dev_props_event->adv_data,
 700                                         adv_info.adv_data, adv_info.len);
 701
 702                         for (i = 0; i < dev_props_event->adv_len; i++)
 703                                 BT_INFO("Adv Data[%d] = [0x%x]",
 704                                         i, dev_props_event->adv_data[i]);
 705                         memcpy(&dev_props_event->device_info,
 706                                 dev_info, sizeof(remote_device_t));
 707                 } else {
 708                         BT_INFO("BREDR type Device");
 709                         memcpy(&dev_props_event->device_info,
 710                                 dev_info, sizeof(remote_device_t));
 711                 }
 712
 713                 event_data = dev_props_event;
 714                 event = OAL_EVENT_DEVICE_PROPERTIES;
 715                 size = sizeof(event_dev_properties_t);
 716                 g_free(dev_info);
 717         }
 718
 719         send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
 720 }
 721
 722 void cb_device_bond_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 723                 bt_bond_state_t state)
 724 {
 725         bt_address_t * address = g_new0(bt_address_t, 1);
 726         oal_event_t event;
 727         gsize size = 0;
 728
 729         BT_DBG("status: %d, state: %d", status, state);
 730
 731         memcpy(address->addr, bd_addr->address, 6);
 732
 733         switch (state) {
 734         case BT_BOND_STATE_BONDED:
 735                 event = OAL_EVENT_DEVICE_BONDING_SUCCESS;
 736                 break;
 737         case BT_BOND_STATE_NONE:
 738                 /* Reaches both when bonding removed or bonding cancelled */
 739                 if (BT_STATUS_SUCCESS != status) {
 740                         event_dev_bond_failed_t * bond_fail_info = g_new0(event_dev_bond_failed_t, 1);
 741                         bond_fail_info->status = convert_to_oal_status(status);
 742                         bond_fail_info->address = *address;
 743                         size = sizeof(event_dev_bond_failed_t);
 744                         send_event_bda_trace(OAL_EVENT_DEVICE_BONDING_FAILED, bond_fail_info, size, (bt_address_t*)bd_addr);
 745                         g_free(address);
 746                         return;
 747                 } else
 748                         event = OAL_EVENT_DEVICE_BONDING_REMOVED;
 749                 break;
 750         case BT_BOND_STATE_BONDING:
 751                 g_free(address);
 752                 return;
 753         default:
 754                 BT_ERR("Unexpected Bond state %d", state);
 755                 g_free(address);
 756                 return;
 757         }
 758         send_event_bda_trace(event, address, sizeof(bt_address_t), (bt_address_t*)bd_addr);
 759 }
 760
 761 void cb_device_acl_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 762                 bt_acl_state_t state)
 763 {
 764         event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
 765         oal_event_t event;
 766         gsize size = 0;
 767
 768         memcpy(conn_status->address.addr, bd_addr->address, 6);
 769
 770 #ifdef TIZEN_BT_HAL
 771         conn_status->status = status;
 772 #else
 773         if (BT_STATUS_SUCCESS != status) {
 774                 /* At present only timeout will cause non-success status, later we can add more */
 775                 conn_status->status = OAL_STATUS_CONN_TIMEOUT;
 776                 BT_ERR("ACL State Error:%d, state: %d", status, state);
 777         } else
 778                 conn_status->status = OAL_STATUS_SUCCESS;
 779
 780         memcpy(conn_status->address.addr, bd_addr->address, 6);
 781 #endif
 782
 783         BT_INFO("[ACL] Status: %d, State: %d", conn_status->status, state);
 784
 785         switch (state) {
 786         case BT_ACL_STATE_CONNECTED:
 787                 event = OAL_EVENT_DEVICE_ACL_CONNECTED;
 788                 conn_status->status = OAL_STATUS_SUCCESS;
 789                 break;
 790         case BT_ACL_STATE_DISCONNECTED:
 791                 event = OAL_EVENT_DEVICE_ACL_DISCONNECTED;
 792                 break;
 793         default:
 794                 BT_ERR("Unexpected ACL state %d", state);
 795                 g_free(conn_status);
 796                 return;
 797         }
 798
 799         size = sizeof(event_dev_conn_status_t);
 800         send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
 801 }
 802
 803 #ifdef TIZEN_BT_HAL
 804 void cb_device_le_conn_state_changed(bt_status_t status, bt_bdaddr_t *bd_addr,
 805                 bt_le_conn_state_t state)
 806 {
 807         event_dev_conn_status_t * conn_status = g_new0(event_dev_conn_status_t, 1);
 808         oal_event_t event;
 809         gsize size = 0;
 810
 811         memcpy(conn_status->address.addr, bd_addr->address, 6);
 812         conn_status->status = status;
 813         BT_INFO("[LE ACL] Status: %d, State: %d", conn_status->status, state);
 814
 815         switch (state) {
 816         case BT_LE_CONN_STATE_CONNECTED:
 817                 event = OAL_EVENT_DEVICE_LE_CONNECTED;
 818                 break;
 819         case BT_LE_CONN_STATE_DISCONNECTED:
 820                 event = OAL_EVENT_DEVICE_LE_DISCONNECTED;
 821                 break;
 822         default:
 823                 BT_ERR("Unexpected ACL state %d", state);
 824                 g_free(conn_status);
 825                 return;
 826         }
 827
 828         size = sizeof(event_dev_conn_status_t);
 829         send_event_bda_trace(event, conn_status, size, (bt_address_t*)bd_addr);
 830 }
 831 #endif
 832
 833 void cb_device_pin_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class)
 834 {
 835         remote_device_t * dev_info = g_new0(remote_device_t, 1);
 836         gsize size = 0;
 837         BT_DBG("+");
 838
 839         memcpy(dev_info->address.addr, bd_addr->address, 6);
 840         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 841         dev_info->cod = device_class;
 842         size = sizeof(remote_device_t);
 843
 844         send_event_bda_trace(OAL_EVENT_DEVICE_PIN_REQUEST, dev_info, size, (bt_address_t*)bd_addr);
 845 }
 846
 847 void cb_device_ssp_request(bt_bdaddr_t *bd_addr, bt_bdname_t *bdname, uint32_t device_class,
 848                 bt_ssp_variant_t pairing_variant, uint32_t pass_key)
 849 {
 850         oal_event_t event;
 851         gpointer event_data = NULL;
 852         gsize size = 0;
 853         BT_DBG("+");
 854
 855         switch (pairing_variant) {
 856         case BT_SSP_VARIANT_PASSKEY_ENTRY:
 857         {
 858                 remote_device_t * dev_info = g_new0(remote_device_t, 1);
 859                 memcpy(dev_info->address.addr, bd_addr->address, 6);
 860                         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 861                 dev_info->cod = device_class;
 862                 event = OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST;
 863                 event_data = dev_info;
 864                 size = sizeof(remote_device_t);
 865                 break;
 866         }
 867         case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
 868         {
 869                 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
 870
 871                 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
 872                         g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 873                 passkey_data->device_info.cod = device_class;
 874                 passkey_data->pass_key = pass_key;
 875                 event = OAL_EVENT_DEVICE_PASSKEY_DISPLAY;
 876                 event_data = passkey_data;
 877                 size = sizeof(event_dev_passkey_t);
 878                 break;
 879         }
 880         case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
 881         {
 882                 event_dev_passkey_t * passkey_data = g_new0(event_dev_passkey_t, 1);
 883
 884                 memcpy(passkey_data->device_info.address.addr, bd_addr->address, 6);
 885                                 g_strlcpy(passkey_data->device_info.name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 886                 passkey_data->device_info.cod = device_class;
 887                 passkey_data->pass_key = pass_key;
 888                 event = OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST;
 889                 event_data = passkey_data;
 890                 size = sizeof(event_dev_passkey_t);
 891                 break;
 892         }
 893         case BT_SSP_VARIANT_CONSENT:
 894         {
 895                 remote_device_t * dev_info = g_new0(remote_device_t, 1);
 896
 897                 memcpy(dev_info->address.addr, bd_addr->address, 6);
 898                         g_strlcpy(dev_info->name, (const gchar *)bdname->name, BT_DEVICE_NAME_LENGTH_MAX);
 899                 dev_info->cod = device_class;
 900                 event = OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST;
 901                 event_data = dev_info;
 902                 size = sizeof(remote_device_t);
 903                 break;
 904         }
 905         default:
 906         {
 907                 BT_ERR("Unhandled SSP request [%d]", pairing_variant);
 908                 return;
 909         }
 910         }
 911         send_event_bda_trace(event, event_data, size, (bt_address_t*)bd_addr);
 912 }
 913
 914 void cb_device_authorize_request(bt_bdaddr_t *bd_addr, bt_service_id_t service_d)
 915 {
 916         event_dev_authorize_req_t * auth_req = g_new0(event_dev_authorize_req_t, 1);
 917
 918         BT_INFO("service_d: %d", service_d);
 919         memcpy(auth_req->address.addr, bd_addr->address, 6);
 920         auth_req->service_id = service_d;
 921
 922         send_event_bda_trace(OAL_EVENT_DEVICE_AUTHORIZE_REQUEST, auth_req, sizeof(event_dev_authorize_req_t), (bt_address_t*)bd_addr);
 923 }
 924
 925 void cb_device_trust_state_changed(bt_bdaddr_t *bd_addr, bt_device_trust_state_t trusted)
 926 {
 927         oal_event_t event;
 928         event_dev_trust_t * trust_val = g_new0(event_dev_trust_t, 1);
 929
 930         if (trusted == BT_DEVICE_TRUSTED) {
 931                 BT_INFO("Device is Trusted");
 932                 event = OAL_EVENT_DEVICE_TRUSTED;
 933         } else {
 934                 BT_INFO("Device is Un Trusted");
 935                 event = OAL_EVENT_DEVICE_UNTRUSTED;
 936         }
 937         memcpy(trust_val->address.addr, bd_addr->address, 6);
 938         trust_val->status = OAL_STATUS_SUCCESS;
 939         send_event_bda_trace(event, trust_val, sizeof(event_dev_trust_t), (bt_address_t*)bd_addr);
 940 }
 941
 942 #ifdef TIZEN_BT_HAL
 943 void cb_socket_conn_authorize_request(bt_bdaddr_t *bd_addr, bt_uuid_t *uuid, uint8_t *name, uint8_t *path, uint32_t fd)
 944 {
 945         event_socket_authorize_req_t *auth_req = g_new0(event_socket_authorize_req_t, 1);
 946
 947         memcpy(auth_req->address.addr, bd_addr->address, 6);
 948         memcpy(auth_req->uuid.uuid, uuid->uu, 16);
 949         memcpy(auth_req->name, name, sizeof(auth_req->name) - 1);
 950         memcpy(auth_req->path, path, sizeof(auth_req->path) - 1);
 951         auth_req->fd = fd;
 952
 953         send_event_bda_trace(OAL_EVENT_SOCKET_AUTHORIZE_REQUEST, auth_req, sizeof(event_socket_authorize_req_t), (bt_address_t*)bd_addr);
 954 }
 955
 956 void cb_device_trusted_profiles_changed(bt_bdaddr_t *bd_addr, uint32_t trust_val)
 957 {
 958         event_device_trusted_profiles_t *ev = g_new0(event_device_trusted_profiles_t, 1);
 959
 960         BT_DBG("+");
 961
 962         memcpy(ev->address.addr, bd_addr->address, 6);
 963         ev->trust_val = trust_val;
 964         send_event_bda_trace(OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED,
 965                         ev, sizeof(event_device_trusted_profiles_t), (bt_address_t*)bd_addr);
 966         BT_DBG("-");
 967 }
 968
 969 void cb_rssi_monitor_state_changed(bt_bdaddr_t *bd_addr, int32_t link_type, uint8_t state)
 970 {
 971         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 972         oal_event_t event = OAL_EVENT_RSSI_MONITORING_ENABLED;
 973
 974         BT_DBG("+");
 975
 976         memcpy(ev->address.addr, bd_addr->address, 6);
 977         ev->link_type = link_type;
 978         if (0 == state)
 979                 event = OAL_EVENT_RSSI_MONITORING_DISABLED;
 980
 981         send_event_bda_trace(event, ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 982
 983         BT_DBG("-");
 984 }
 985
 986 void cb_rssi_alert(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t alert_type, int32_t rssi)
 987 {
 988         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
 989
 990         BT_DBG("+");
 991
 992         memcpy(ev->address.addr, bd_addr->address, 6);
 993         ev->link_type = link_type;
 994         ev->alert_type = alert_type;
 995         ev->rssi = rssi;
 996
 997         send_event_bda_trace(OAL_EVENT_RSSI_ALERT_RECEIVED,
 998                         ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
 999         BT_DBG("-");
1000 }
1001
1002 void cb_raw_rssi_received(bt_bdaddr_t *bd_addr, int32_t link_type, int32_t rssi)
1003 {
1004         event_dev_rssi_info_t *ev = g_new0(event_dev_rssi_info_t, 1);
1005
1006         BT_DBG("+");
1007
1008         memcpy(ev->address.addr, bd_addr->address, 6);
1009         ev->link_type = link_type;
1010         ev->rssi = rssi;
1011
1012         send_event_bda_trace(OAL_EVENT_RAW_RSSI_RECEIVED,
1013                         ev, sizeof(event_dev_rssi_info_t), (bt_address_t*)bd_addr);
1014         BT_DBG("-");
1015 }
1016
1017 void cb_dbfw_plus_info_received(unsigned char *data, uint32_t length, uint8_t event_code)
1018 {
1019         event_dev_dbfw_plus_info_t *dbfw_info;
1020         int len = (length > 512)?512:length;
1021
1022         ret_if(data == NULL || length == 0);
1023
1024         dbfw_info = g_new0(event_dev_dbfw_plus_info_t, 1);
1025         dbfw_info->event_code = event_code;
1026         memcpy(dbfw_info->data, data, len);
1027         dbfw_info->length = len;
1028
1029         send_event(OAL_EVENT_DEVICE_DBFW_PLUS_INFO,
1030                 dbfw_info, sizeof(event_dev_dbfw_plus_info_t));
1031 }
1032
1033 #endif