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