bt-service-adaptation/services/adapter/bt-service-core-adapter.c

   1 /*
   2  * Copyright (c) 2015 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Contact: Anupam Roy <anupam.r@samsung.com>
   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 <gio/gio.h>
  22 #include <glib.h>
  23 #include <dlog.h>
  24 #include <string.h>
  25 #include <vconf.h>
  26 #include <vconf-internal-keys.h>
  27 #include <syspopup_caller.h>
  28 #include <aul.h>
  29 #include <eventsystem.h>
  30 #include <bundle_internal.h>
  31
  32 #include "alarm.h"
  33
  34 /*bt-service headers */
  35 #include "bt-internal-types.h"
  36 #include "bt-service-common.h"
  37 #include "bt-service-util.h"
  38 #include "bt-service-main.h"
  39 #include "bt-service-core-adapter.h"
  40 #include "bt-service-core-device.h"
  41 #include "bt-service-event-receiver.h"
  42 #include "bt-request-handler.h"
  43 #include "bt-service-event.h"
  44 #ifdef TIZEN_DPM_ENABLE
  45 #include "bt-service-dpm.h"
  46 #endif
  47 #include "bt-service-hidhost.h"
  48 #include "bt-service-socket.h"
  49
  50 /* OAL headers */
  51 #include <oal-event.h>
  52 #include <oal-manager.h>
  53 #include <oal-adapter-mgr.h>
  54
  55 #define BT_ENABLE_TIMEOUT 20000 /* 20 seconds */
  56
  57 /*This file will contain state machines related to adapter and remote device */
  58
  59 /* Global variables */
  60 typedef struct {
  61         guint event_id;
  62         int timeout;
  63         time_t start_time;
  64         gboolean alarm_init;
  65         int alarm_id;
  66 } bt_adapter_timer_t;
  67
  68 static bt_adapter_timer_t visible_timer;
  69
  70 static guint timer_id = 0;
  71
  72 /* Adapter default states */
  73 static bt_status_t adapter_state = BT_DEACTIVATED;
  74 static bt_adapter_discovery_state_t adapter_discovery_state = ADAPTER_DISCOVERY_STOPPED;
  75
  76 /* Forward declarations */
  77 static void __bt_adapter_event_handler(int event_type, gpointer event_data);
  78 static void __bt_post_oal_init(void);
  79 static void __bt_handle_oal_initialisation(oal_event_t event);
  80 static void __bt_adapter_handle_pending_requests(int service_function, void *user_data, unsigned int size);
  81 static gboolean __bt_adapter_post_set_enabled(gpointer user_data);
  82 static gboolean __bt_adapter_post_set_disabled(gpointer user_data);
  83 static void __bt_adapter_update_bt_enabled(void);
  84 static void __bt_adapter_update_bt_disabled(void);
  85 static void __bt_adapter_state_set_status(bt_status_t status);
  86 static void __bt_adapter_update_discovery_status(bt_adapter_discovery_state_t status);
  87 static void __bt_adapter_state_change_callback(int bt_status);
  88 static int __bt_adapter_state_handle_request(gboolean enable);
  89 static int __bt_adapter_state_discovery_request(gboolean enable);
  90 static void __bt_adapter_discovery_state_change_callback(int bt_discovery_status);
  91 static gboolean __bt_is_service_request_present(int service_function);
  92 #ifdef TIZEN_MOBILE
  93 static void __bt_set_visible_mode(void);
  94 #endif
  95 static void __bt_set_local_name(void);
  96
  97 /* Initialize BT stack (Initialize OAL layer) */
  98 int _bt_stack_init(void)
  99 {
 100         int ret;
 101
 102         BT_INFO("[bt-service] Start to initialize BT stack");
 103         /* Adapter enable request is successful, setup event handlers */
 104         _bt_service_register_event_handler_callback(
 105                         BT_ADAPTER_MODULE, __bt_adapter_event_handler);
 106
 107         ret = oal_bt_init(_bt_service_oal_event_receiver);
 108
 109         if (OAL_STATUS_PENDING == ret) {
 110                 BT_INFO("OAL Initialisation Pending, Profiles Init will be done once oal initialised...");
 111                 return BLUETOOTH_ERROR_NONE;
 112         } else if (OAL_STATUS_SUCCESS != ret) {
 113                 _bt_service_unregister_event_handler_callback(BT_ADAPTER_MODULE);
 114                 return BLUETOOTH_ERROR_INTERNAL;
 115         }
 116
 117         __bt_post_oal_init();
 118         return BLUETOOTH_ERROR_NONE;
 119 }
 120
 121 int _bt_enable_adapter(void)
 122 {
 123         return __bt_adapter_state_handle_request(TRUE);
 124 }
 125
 126 int _bt_disable_adapter(void)
 127 {
 128         return __bt_adapter_state_handle_request(FALSE);
 129 }
 130
 131
 132 int _bt_start_discovery(void)
 133 {
 134         return __bt_adapter_state_discovery_request(TRUE);
 135 }
 136
 137 int _bt_cancel_discovery(void)
 138 {
 139         return __bt_adapter_state_discovery_request(FALSE);
 140 }
 141
 142 gboolean _bt_is_discovering(void)
 143 {
 144         if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED
 145                         || adapter_discovery_state == ADAPTER_DISCOVERY_STARTING)
 146                 return TRUE;
 147         else
 148                 return FALSE;
 149 }
 150
 151 int _bt_get_local_address(void)
 152 {
 153         int result;
 154
 155         BT_DBG("+");
 156
 157         result =  adapter_get_address();
 158         if (result != OAL_STATUS_SUCCESS) {
 159                 BT_ERR("adapter_get_address failed: %d", result);
 160                 result = BLUETOOTH_ERROR_INTERNAL;
 161         } else
 162                 result = BLUETOOTH_ERROR_NONE;
 163
 164         BT_DBG("-");
 165         return result;
 166 }
 167
 168 int _bt_get_local_version(void)
 169 {
 170         int result;
 171         BT_DBG("+");
 172
 173         result =  adapter_get_version();
 174         if (result != OAL_STATUS_SUCCESS) {
 175                 BT_ERR("adapter_get_address failed: %d", result);
 176                 result = BLUETOOTH_ERROR_INTERNAL;
 177         } else
 178                 result = BLUETOOTH_ERROR_NONE;
 179
 180         BT_DBG("-");
 181         return result;
 182 }
 183
 184 int _bt_get_local_name(void)
 185 {
 186         int result;
 187
 188         BT_DBG("+");
 189
 190         result =  adapter_get_name();
 191         if (result != OAL_STATUS_SUCCESS) {
 192                 BT_ERR("adapter_get_name failed: %d", result);
 193                 result = BLUETOOTH_ERROR_INTERNAL;
 194         } else
 195                 result = BLUETOOTH_ERROR_NONE;
 196
 197         BT_DBG("-");
 198         return result;
 199 }
 200
 201 int _bt_set_local_name(char *local_name)
 202 {
 203         int result = BLUETOOTH_ERROR_NONE;
 204         BT_DBG("+");
 205
 206         retv_if(NULL == local_name, BLUETOOTH_ERROR_INVALID_PARAM);
 207
 208         result =  adapter_set_name(local_name);
 209         if (result != OAL_STATUS_SUCCESS) {
 210                 BT_ERR("adapter_set_name failed: %d", result);
 211                 result = BLUETOOTH_ERROR_INTERNAL;
 212         } else
 213                 result = BLUETOOTH_ERROR_NONE;
 214
 215         BT_DBG("-");
 216         return result;
 217 }
 218
 219 int _bt_get_discoverable_mode(int *mode)
 220 {
 221         int scan_mode = 0;
 222         int timeout = 0;
 223
 224         BT_DBG("+");
 225
 226         retv_if(NULL == mode, BLUETOOTH_ERROR_INVALID_PARAM);
 227
 228         adapter_is_discoverable(&scan_mode);
 229         if (TRUE == scan_mode) {
 230                 adapter_get_discoverable_timeout(&timeout);
 231                 if (timeout > 0)
 232                         *mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
 233                 else
 234                         *mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 235         } else {
 236                 adapter_is_connectable(&scan_mode);
 237                 if(scan_mode == TRUE)
 238                         *mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 239                 else {
 240                         /*
 241                          * TODO: NON CONNECTABLE is not defined in bluetooth_discoverable_mode_t.
 242                          * After adding BLUETOOTH_DISCOVERABLE_MODE_NON_CONNECTABLE, set mode as
 243                          * BLUETOOTH_DISCOVERABLE_MODE_NON_CONNECTABLE. Until then set -1.
 244                          */
 245                         *mode = -1;
 246                 }
 247         }
 248
 249         BT_DBG("-");
 250         return BLUETOOTH_ERROR_NONE;
 251 }
 252
 253 int _bt_get_timeout_value(int *timeout)
 254 {
 255         time_t current_time;
 256         int time_diff;
 257
 258         /* Take current time */
 259         time(&current_time);
 260         time_diff = difftime(current_time, visible_timer.start_time);
 261
 262         BT_DBG("Time diff = %d\n", time_diff);
 263         *timeout = visible_timer.timeout - time_diff;
 264
 265         return BLUETOOTH_ERROR_NONE;
 266 }
 267
 268 static void __bt_visibility_alarm_remove()
 269 {
 270         if (visible_timer.event_id > 0) {
 271                 g_source_remove(visible_timer.event_id);
 272                 visible_timer.event_id = 0;
 273         }
 274
 275         if (visible_timer.alarm_id > 0) {
 276                 alarmmgr_remove_alarm(visible_timer.alarm_id);
 277                 visible_timer.alarm_id = 0;
 278         }
 279 }
 280
 281 static int __bt_visibility_alarm_cb(alarm_id_t alarm_id, void* user_param)
 282 {
 283         int result = BLUETOOTH_ERROR_NONE;
 284         int timeout = 0;
 285
 286         BT_DBG("__bt_visibility_alarm_cb - alram id = [%d] \n", alarm_id);
 287
 288         if (alarm_id != visible_timer.alarm_id)
 289                 return 0;
 290
 291         if (visible_timer.event_id) {
 292                 _bt_send_event(BT_ADAPTER_EVENT,
 293                                 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 294                                 g_variant_new("(in)", result, timeout));
 295                 g_source_remove(visible_timer.event_id);
 296                 visible_timer.event_id = 0;
 297                 visible_timer.timeout = 0;
 298
 299 #ifndef TIZEN_WEARABLE
 300                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
 301                         BT_ERR("Set vconf failed\n");
 302 #endif
 303         }
 304         /* Switch Off visibility in Bluez */
 305         _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
 306         visible_timer.alarm_id = 0;
 307         return 0;
 308 }
 309
 310 static gboolean __bt_timeout_handler(gpointer user_data)
 311 {
 312         int result = BLUETOOTH_ERROR_NONE;
 313         time_t current_time;
 314         int time_diff;
 315
 316         /* Take current time */
 317         time(&current_time);
 318         time_diff = difftime(current_time, visible_timer.start_time);
 319
 320         /* Send event to application */
 321         _bt_send_event(BT_ADAPTER_EVENT,
 322                         BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 323                         g_variant_new("(in)", result, time_diff));
 324
 325         if (visible_timer.timeout <= time_diff) {
 326                 g_source_remove(visible_timer.event_id);
 327                 visible_timer.event_id = 0;
 328                 visible_timer.timeout = 0;
 329
 330 #ifndef TIZEN_WEARABLE
 331                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
 332                         BT_ERR("Set vconf failed\n");
 333 #endif
 334                 return FALSE;
 335         }
 336
 337         return TRUE;
 338 }
 339
 340 static void __bt_visibility_alarm_create()
 341 {
 342         alarm_id_t alarm_id;
 343         int result;
 344
 345         result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, visible_timer.timeout,
 346                         0, NULL, &alarm_id);
 347         if (result < 0) {
 348                 BT_ERR("Failed to create alarm error = %d\n", result);
 349         } else {
 350                 BT_DBG("Alarm created = %d\n", alarm_id);
 351                 visible_timer.alarm_id = alarm_id;
 352         }
 353 }
 354
 355 static int __bt_set_visible_time(int timeout)
 356 {
 357         int result;
 358
 359         __bt_visibility_alarm_remove();
 360
 361         visible_timer.timeout = timeout;
 362
 363 #ifndef TIZEN_WEARABLE
 364 #ifdef TIZEN_DPM_ENABLE
 365         if (_bt_dpm_get_bluetooth_limited_discoverable_state() != DPM_RESTRICTED) {
 366 #endif
 367                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
 368                         BT_ERR("Set vconf failed");
 369 #ifdef TIZEN_DPM_ENABLE
 370         }
 371 #endif
 372 #endif
 373
 374         if (timeout <= 0)
 375                 return BLUETOOTH_ERROR_NONE;
 376
 377         if (!visible_timer.alarm_init) {
 378                 /* Set Alarm timer to switch off BT */
 379                 result = alarmmgr_init("bt-service");
 380                 if (result != 0)
 381                         return BLUETOOTH_ERROR_INTERNAL;
 382
 383                 visible_timer.alarm_init = TRUE;
 384         }
 385
 386         result = alarmmgr_set_cb(__bt_visibility_alarm_cb, NULL);
 387         if (result != 0)
 388                 return BLUETOOTH_ERROR_INTERNAL;
 389
 390         /* Take start time */
 391         time(&(visible_timer.start_time));
 392         visible_timer.event_id = g_timeout_add_seconds(1,
 393                         __bt_timeout_handler, NULL);
 394
 395         __bt_visibility_alarm_create();
 396
 397         return BLUETOOTH_ERROR_NONE;
 398 }
 399
 400 int _bt_set_discoverable_mode(int discoverable_mode, int timeout)
 401 {
 402         int result;
 403
 404         BT_DBG("+");
 405
 406         BT_INFO("discoverable_mode: %d, timeout: %d", discoverable_mode, timeout);
 407
 408 #ifdef TIZEN_DPM_ENABLE
 409         if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE &&
 410                         _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
 411                 _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT_HANDSFREE");
 412                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 413         }
 414         if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE &&
 415                         _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
 416                 _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT");
 417                 return BLUETOOTH_ERROR_ACCESS_DENIED;
 418         }
 419 #endif
 420
 421         switch (discoverable_mode) {
 422         case BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE:
 423                 result = adapter_set_connectable(TRUE);
 424                 timeout = 0;
 425                 break;
 426         case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
 427                 result = adapter_set_discoverable();
 428                 timeout = 0;
 429                 break;
 430         case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
 431                 result = adapter_set_discoverable();
 432                 break;
 433         default:
 434                 return BLUETOOTH_ERROR_INVALID_PARAM;
 435         }
 436
 437         if (result != OAL_STATUS_SUCCESS) {
 438                 BT_ERR("set scan mode failed %d", result);
 439                 return BLUETOOTH_ERROR_INTERNAL;
 440         }
 441
 442         result = adapter_set_discoverable_timeout(timeout);
 443         if (result != OAL_STATUS_SUCCESS) {
 444                 BT_ERR("adapter_set_discoverable_timeout failed %d", result);
 445                 return BLUETOOTH_ERROR_INTERNAL;
 446         }
 447
 448         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
 449                 timeout = -1;
 450
 451         result = __bt_set_visible_time(timeout);
 452
 453         BT_DBG("-");
 454         return result;
 455 }
 456
 457 gboolean _bt_is_connectable(void)
 458 {
 459         int connectable = 0;
 460         int result;
 461
 462         BT_DBG("+");
 463
 464         adapter_is_connectable(&connectable);
 465         if (connectable)
 466                 result = TRUE;
 467         else
 468                 result = FALSE;
 469
 470         BT_DBG("Connectable: [%s]", result ? "TRUE":"FALSE");
 471         BT_DBG("-");
 472         return result;
 473 }
 474
 475 int _bt_set_connectable(gboolean connectable)
 476 {
 477         int result = BLUETOOTH_ERROR_NONE;
 478
 479         BT_DBG("+");
 480         result =  adapter_set_connectable(connectable);
 481         if (result != OAL_STATUS_SUCCESS) {
 482                 BT_ERR("adapter_get_address failed: %d", result);
 483                 result = BLUETOOTH_ERROR_INTERNAL;
 484         } else
 485                 result = BLUETOOTH_ERROR_NONE;
 486
 487         BT_DBG("-");
 488         return result;
 489 }
 490
 491 int _bt_is_service_used(void)
 492 {
 493         int result;
 494
 495         BT_DBG("+");
 496
 497         result =  adapter_get_service_uuids();
 498         if (result != OAL_STATUS_SUCCESS) {
 499                 BT_ERR("adapter_get_service_uuids failed: %d", result);
 500                 result = BLUETOOTH_ERROR_INTERNAL;
 501         } else {
 502                 result = BLUETOOTH_ERROR_NONE;
 503         }
 504
 505         BT_DBG("-");
 506         return result;
 507 }
 508
 509 int _bt_adapter_get_bonded_devices(void)
 510 {
 511         int result = BLUETOOTH_ERROR_NONE;
 512
 513         BT_DBG("+");
 514         result =  adapter_get_bonded_devices();
 515         if (result != OAL_STATUS_SUCCESS) {
 516                 BT_ERR("adapter_get_bonded_devices failed: %d", result);
 517                 result = BLUETOOTH_ERROR_INTERNAL;
 518         } else
 519                 result = BLUETOOTH_ERROR_NONE;
 520
 521         BT_DBG("-");
 522         return result;
 523 }
 524
 525 static void __bt_adapter_event_handler(int event_type, gpointer event_data)
 526 {
 527         int result = BLUETOOTH_ERROR_NONE;
 528
 529         BT_DBG("+");
 530
 531         switch(event_type) {
 532         case OAL_EVENT_OAL_INITIALISED_SUCCESS:
 533         case OAL_EVENT_OAL_INITIALISED_FAILED:
 534                 __bt_handle_oal_initialisation(event_type);
 535                 break;
 536         case OAL_EVENT_ADAPTER_ENABLED:
 537                 __bt_adapter_state_change_callback(BT_ACTIVATED);
 538                 break;
 539         case OAL_EVENT_ADAPTER_DISABLED:
 540                 __bt_adapter_state_change_callback(BT_DEACTIVATED);
 541                 break;
 542         case OAL_EVENT_ADAPTER_INQUIRY_STARTED:
 543                 __bt_adapter_discovery_state_change_callback(ADAPTER_DISCOVERY_STARTED);
 544                 break;
 545         case OAL_EVENT_ADAPTER_INQUIRY_FINISHED:
 546                 __bt_adapter_discovery_state_change_callback(ADAPTER_DISCOVERY_STOPPED);
 547                 break;
 548         case OAL_EVENT_ADAPTER_PROPERTY_ADDRESS: {
 549                 bt_address_t *bd_addr = event_data;
 550                 bluetooth_device_address_t local_address;
 551
 552                 /* Copy data */
 553                 memcpy(local_address.addr, bd_addr->addr, BT_ADDRESS_LENGTH_MAX);
 554                 BT_DBG("Adapter address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
 555                                 local_address.addr[0], local_address.addr[1], local_address.addr[2],
 556                                 local_address.addr[3], local_address.addr[4], local_address.addr[5]);
 557
 558                 __bt_adapter_handle_pending_requests(BT_GET_LOCAL_ADDRESS,
 559                                 (void *) &local_address, sizeof(bluetooth_device_address_t));
 560                 break;
 561         }
 562         case OAL_EVENT_ADAPTER_PROPERTY_NAME: {
 563                 char *name = event_data;
 564                 BT_DBG("Adapter Name: %s", name);
 565
 566                 if (__bt_is_service_request_present(BT_GET_LOCAL_NAME)) {
 567                         bluetooth_device_name_t local_name;
 568
 569                         memset(&local_name, 0x00, sizeof(bluetooth_device_name_t));
 570                         g_strlcpy(local_name.name,
 571                                 (const gchar *)name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 572                         __bt_adapter_handle_pending_requests(BT_GET_LOCAL_NAME,
 573                                 (void *) &local_name, sizeof(bluetooth_device_name_t));
 574                 } else {
 575                         /* Send event to application */
 576                         _bt_send_event(BT_ADAPTER_EVENT,
 577                                         BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 578                                         g_variant_new("(is)", result, name));
 579                 }
 580                 break;
 581         }
 582         case OAL_EVENT_ADAPTER_PROPERTY_VERSION: {
 583                 char *ver = event_data;
 584                 bluetooth_version_t local_version;
 585
 586                 memset(&local_version, 0x00, sizeof(bluetooth_version_t));
 587                 g_strlcpy(local_version.version,
 588                                 (const gchar *)ver, BLUETOOTH_VERSION_LENGTH_MAX);
 589                 BT_DBG("BT Version: %s", local_version.version);
 590
 591                 __bt_adapter_handle_pending_requests(BT_GET_LOCAL_VERSION,
 592                                 (void *) &local_version, sizeof(bluetooth_version_t));
 593                 break;
 594         }
 595         case OAL_EVENT_ADAPTER_MODE_NON_CONNECTABLE: {
 596                 int mode = -1;
 597                 gboolean connectable = FALSE;
 598
 599                 BT_INFO("Adapter discoverable mode:"
 600                                 " BLUETOOTH_DISCOVERABLE_MODE_NON_CONNECTABLE");
 601                 _bt_send_event(BT_ADAPTER_EVENT,
 602                                 BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 603                                 g_variant_new("(b)", connectable));
 604
 605                 _bt_send_event(BT_ADAPTER_EVENT,
 606                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 607                                 g_variant_new("(in)", result, mode));
 608                 break;
 609         }
 610         case OAL_EVENT_ADAPTER_MODE_CONNECTABLE: {
 611                 int mode;
 612                 gboolean connectable = TRUE;
 613
 614                 BT_INFO("Adapter discoverable mode:"
 615                                 " BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE");
 616                 _bt_send_event(BT_ADAPTER_EVENT,
 617                                 BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 618                                 g_variant_new("(b)", connectable));
 619
 620                 mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 621                 _bt_send_event(BT_ADAPTER_EVENT,
 622                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 623                                 g_variant_new("(in)", result, mode));
 624                 break;
 625         }
 626         case OAL_EVENT_ADAPTER_MODE_DISCOVERABLE: {
 627                 int mode;
 628
 629                 BT_INFO("Adapter discoverable mode:"
 630                                 " BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE");
 631
 632                 /* Send event to application */
 633                 mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 634                 _bt_send_event(BT_ADAPTER_EVENT,
 635                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 636                                 g_variant_new("(in)", result, mode));
 637
 638                 break;
 639         }
 640         case OAL_EVENT_ADAPTER_MODE_DISCOVERABLE_TIMEOUT: {
 641                 int *timeout = event_data;
 642                 int mode;
 643
 644                 BT_INFO("Discoverable timeout: [%d]", *timeout);
 645
 646                 /* Send event to application */
 647                 _bt_get_discoverable_mode(&mode);
 648                 _bt_send_event(BT_ADAPTER_EVENT,
 649                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 650                                 g_variant_new("(in)", result, mode));
 651                 break;
 652         }
 653         case OAL_EVENT_ADAPTER_PROPERTY_SERVICES: {
 654                 int count;
 655                 service_uuid_t *service_list;
 656                 event_adapter_services_t *list = event_data;
 657
 658                 count = list->num;
 659                 service_list = list->service_list;
 660                 __bt_adapter_handle_pending_requests(BT_IS_SERVICE_USED, service_list, count);
 661                 break;
 662         }
 663         case OAL_EVENT_ADAPTER_BONDED_DEVICE_LIST: {
 664                 int i;
 665                 int count;
 666                 bluetooth_device_address_t *addr_list;
 667
 668                 event_device_list_t *bonded_device_list = event_data;
 669                 count = bonded_device_list->num;
 670
 671                 addr_list = g_malloc0(count * sizeof(bluetooth_device_address_t));
 672                 for (i = 0; i < count; i++) {
 673                         memcpy(addr_list[i].addr,
 674                                         bonded_device_list->devices[i].addr,
 675                                         BLUETOOTH_ADDRESS_LENGTH);
 676                 }
 677
 678                 __bt_adapter_handle_pending_requests(BT_GET_BONDED_DEVICES,
 679                                 (void *)addr_list, bonded_device_list->num);
 680                 break;
 681         }
 682         default:
 683                 BT_ERR("Unhandled event..");
 684                 break;
 685         }
 686
 687         BT_DBG("-");
 688 }
 689
 690 static int __bt_init_profiles()
 691 {
 692         int ret;
 693
 694         /*TODO: Init bluetooth profiles */
 695         ret = _bt_hidhost_initialize();
 696         if (ret != BLUETOOTH_ERROR_NONE) {
 697                 BT_ERR("_bt_hidhost_initialize Failed");
 698                 return ret;
 699         }
 700         ret = _bt_socket_init();
 701         if (ret != BLUETOOTH_ERROR_NONE) {
 702                 BT_ERR("_bt_socket_init Failed");
 703                 return ret;
 704         }
 705
 706         return BLUETOOTH_ERROR_NONE;
 707 }
 708
 709 /* OAL post initialization handler */
 710 static void __bt_post_oal_init(void)
 711 {
 712         int ret;
 713
 714         BT_DBG("OAL initialized, Init profiles..");
 715         ret = __bt_init_profiles();
 716         if (ret != BLUETOOTH_ERROR_NONE)
 717                 BT_ERR("Bluetooth profile init error: %d", ret);
 718
 719         return;
 720 }
 721
 722 /* OAL initialization handler */
 723 static void __bt_handle_oal_initialisation(oal_event_t event)
 724 {
 725         BT_DBG("");
 726
 727         switch(event) {
 728         case OAL_EVENT_OAL_INITIALISED_SUCCESS:
 729                 __bt_post_oal_init();
 730                 break;
 731         case OAL_EVENT_OAL_INITIALISED_FAILED:
 732                 BT_ERR("OAL Initialisation Failed, terminate bt-service daemon..");
 733                 g_idle_add(_bt_terminate_service, NULL);
 734                 break;
 735         default:
 736                 BT_ERR("Unknown Event");
 737                 break;
 738         }
 739 }
 740
 741 static gboolean __bt_is_service_request_present(int service_function)
 742 {
 743         GSList *l;
 744         invocation_info_t *req_info;
 745
 746         BT_DBG("+");
 747
 748         /* Get method invocation context */
 749         for (l = _bt_get_invocation_list(); l != NULL; l = g_slist_next(l)) {
 750                 req_info = l->data;
 751                 if (req_info && req_info->service_function == service_function)
 752                         return TRUE;
 753         }
 754
 755         BT_DBG("-");
 756         return FALSE;
 757 }
 758
 759 /* Internal functions of core adapter service */
 760 static void __bt_adapter_handle_pending_requests(int service_function, void *user_data, unsigned int size)
 761 {
 762         GSList *l;
 763         GArray *out_param;
 764         invocation_info_t *req_info;
 765         BT_INFO("+");
 766
 767         /* Get method invocation context */
 768         for (l = _bt_get_invocation_list(); l != NULL; l = g_slist_next(l)) {
 769                 req_info = l->data;
 770                 if (req_info == NULL || req_info->service_function != service_function)
 771                         continue;
 772
 773                 /* Create out param */
 774                 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
 775
 776                 switch(service_function) {
 777                 case BT_ENABLE_ADAPTER:
 778                 case BT_DISABLE_ADAPTER: {
 779                         gboolean done = TRUE;
 780                         g_array_append_vals(out_param, &done, sizeof(gboolean));
 781                         break;
 782                 }
 783                 case BT_GET_LOCAL_NAME:
 784                 case BT_GET_LOCAL_ADDRESS:
 785                 case BT_GET_LOCAL_VERSION:
 786                         g_array_append_vals(out_param, user_data, size);
 787                         break;
 788                 case BT_IS_SERVICE_USED: {
 789                         int i;
 790                         gboolean used = FALSE;
 791                         unsigned char *uuid;
 792                         char uuid_str[BT_UUID_STRING_SIZE];
 793                         char *request_uuid = req_info->user_data;
 794                         service_uuid_t *service_list = user_data;
 795
 796                         BT_INFO("Check for service uuid: %s", request_uuid);
 797                         for (i = 0; i < size; i++) {
 798                                 uuid = service_list[i].uuid;
 799                                 _bt_service_convert_uuid_type_to_string(uuid_str, uuid);
 800                                 BT_INFO("Adapter Service: [%s]", uuid_str);
 801                                 if (strcasecmp(uuid_str, request_uuid) == 0) {
 802                                         BT_INFO("UUID matched!!");
 803                                         used = TRUE;
 804                                         break;
 805                                 }
 806                         }
 807
 808                         g_array_append_vals(out_param, &used, sizeof(gboolean));
 809                         break;
 810                 }
 811                 case BT_GET_BONDED_DEVICES: {
 812                         bluetooth_device_address_t *addr_list = user_data;
 813                         bonded_devices_req_info_t *bonded_devices_req_info;
 814                         char address[BT_ADDRESS_STRING_SIZE];
 815                         int count = size;
 816                         int res = BLUETOOTH_ERROR_NONE;
 817
 818                         /*
 819                          * BT_GET_BONDED_DEVICES is already processed for this request,
 820                          * continue for next BT_GET_BONDED_DEVICES request if any
 821                          */
 822                         if (NULL != req_info->user_data)
 823                                 continue;
 824
 825                         BT_DBG("BT_GET_BONDED_DEVICES: count = [%d]", count);
 826                         /* No bonded devices, return method invocation */
 827                         if (0 == count || !addr_list)
 828                                 break;
 829
 830                         /* Save address list in user data  for futur reference. */
 831                         bonded_devices_req_info = g_malloc0(sizeof(bonded_devices_req_info));
 832                         if (!bonded_devices_req_info) {
 833                                 BT_ERR("Memory allocation failed");
 834                                 req_info->result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 835                                 g_free(addr_list);
 836                                 break;
 837                         }
 838
 839                         bonded_devices_req_info->count = count;
 840                         bonded_devices_req_info->addr_list = addr_list;
 841                         bonded_devices_req_info->out_param = out_param;
 842                         req_info->user_data = bonded_devices_req_info;
 843
 844                         while (bonded_devices_req_info->count > 0) {
 845                                 bonded_devices_req_info->count -= 1;
 846                                 res = _bt_device_get_bonded_device_info(
 847                                                 &addr_list[bonded_devices_req_info->count]);
 848                                 if (BLUETOOTH_ERROR_NONE == res)
 849                                         return;
 850                                 else {
 851                                         _bt_convert_addr_type_to_string((char *)address,
 852                                                         addr_list[bonded_devices_req_info->count].addr);
 853                                         BT_ERR("_bt_device_get_bonded_device_info Failed for [%s]", address);
 854                                         if (bonded_devices_req_info->count == 0) {
 855                                                 g_free(bonded_devices_req_info->addr_list);
 856                                                 g_free(bonded_devices_req_info);
 857                                                 req_info->user_data = NULL;
 858                                         }
 859                                 }
 860                         }
 861                         break;
 862                 }
 863                 default:
 864                         BT_ERR("Unknown service function[%d]", service_function);
 865                 }
 866
 867                 _bt_service_method_return(req_info->context, out_param, req_info->result);
 868                 g_array_free(out_param, TRUE);
 869                 /* Now free invocation info for this request*/
 870                 _bt_free_info_from_invocation_list(req_info);
 871         }
 872 }
 873
 874 /* Request return handlings */
 875 static gboolean __bt_adapter_post_set_enabled(gpointer user_data)
 876 {
 877         BT_INFO("__bt_adapter_post_set_enabled>>");
 878
 879 #ifdef TIZEN_MOBILE
 880         __bt_set_visible_mode();
 881 #else
 882 #ifdef TIZEN_TV
 883         if (BLUETOOTH_ERROR_NONE != _bt_set_discoverable_mode(
 884                         BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0))
 885                 BT_ERR("Fail to set discoverable mode");
 886 #endif
 887 #endif
 888         __bt_set_local_name();
 889
 890         /* Get All properties */
 891         if (OAL_STATUS_SUCCESS != adapter_get_properties())
 892                 BT_ERR("adapter_get_properties failed");
 893
 894         /* Add Adapter enabled post processing codes */
 895         return FALSE;
 896 }
 897
 898 static gboolean __bt_adapter_post_set_disabled(gpointer user_data)
 899 {
 900         BT_INFO("_bt_adapter_post_set_disabled>>");
 901         /* Add Adapter disabled post processing codes */
 902         return FALSE;
 903 }
 904
 905 static void __bt_adapter_update_bt_enabled(void)
 906 {
 907         int result = BLUETOOTH_ERROR_NONE;
 908         BT_INFO("_bt_adapter_update_bt_enabled>>");
 909         /* Update Bluetooth Status to notify other modules */
 910         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
 911                 BT_ERR("Set vconf failed\n");
 912
 913         /* TODO:Add timer function to handle any further post processing */
 914         g_idle_add((GSourceFunc)__bt_adapter_post_set_enabled, NULL);
 915
 916         /*Return BT_ADAPTER_ENABLE Method invocation context */
 917         __bt_adapter_handle_pending_requests(BT_ENABLE_ADAPTER, NULL, 0);
 918         /*Send BT Enabled event to application */
 919         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
 920                         g_variant_new("(i)", result));
 921 }
 922
 923 static void __bt_adapter_update_bt_disabled(void)
 924 {
 925         int result = BLUETOOTH_ERROR_NONE;
 926         BT_INFO("_bt_adapter_update_bt_disabled>>");
 927
 928         int power_off_status = 0;
 929         int ret;
 930
 931         /* Update the vconf BT status in normal Deactivation case only */
 932         ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
 933         BT_DBG("ret : %d, power_off_status : %d", ret, power_off_status);
 934
 935         /* TODO:Add timer function to handle any further post processing */
 936         g_idle_add((GSourceFunc)__bt_adapter_post_set_disabled, NULL);
 937
 938         /* Return BT_ADAPTER_DISABLE Method invocation context */
 939         __bt_adapter_handle_pending_requests(BT_DISABLE_ADAPTER, NULL, 0);
 940
 941         /* Send BT Disabled event to application */
 942         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
 943                         g_variant_new("(i)", result));
 944 }
 945
 946
 947 static void __bt_adapter_state_set_status(bt_status_t status)
 948 {
 949         BT_INFO("adapter_status changed [%d] -> [%d]", adapter_state, status);
 950         adapter_state = status;
 951 }
 952
 953 static void __bt_adapter_update_discovery_status(bt_adapter_discovery_state_t status)
 954 {
 955         BT_INFO("adapter_discovery_status changed [%d] -> [%d]", adapter_discovery_state, status);
 956         adapter_discovery_state = status;
 957 }
 958
 959 static void __bt_adapter_state_change_callback(int bt_status)
 960 {
 961         BT_INFO("__bt_adapter_state_change_callback: status [%d]", bt_status);
 962
 963         switch (bt_status) {
 964         case BT_DEACTIVATED:
 965                 __bt_adapter_state_set_status(bt_status);
 966
 967                 /* Adapter is disabled, unregister event handlers */
 968                 _bt_service_unregister_event_handler_callback(BT_ADAPTER_MODULE);
 969                 //_bt_deinit_device_event_handler();
 970
 971                 /* Add Adapter disabled post processing codes */
 972                 __bt_adapter_update_bt_disabled();
 973                 break;
 974         case BT_ACTIVATED:
 975                 __bt_adapter_state_set_status(bt_status);
 976                 /* Add Adapter enabled post processing codes */
 977                 if (timer_id > 0) {
 978                         BT_DBG("g_source is removed");
 979                         g_source_remove(timer_id);
 980                         timer_id = 0;
 981                 }
 982                 __bt_adapter_update_bt_enabled();
 983                 break;
 984         default:
 985                 BT_ERR("Incorrect Bluetooth adapter state changed status");
 986
 987         }
 988 }
 989
 990 static int __bt_adapter_state_handle_request(gboolean enable)
 991 {
 992         int result = BLUETOOTH_ERROR_NONE;
 993         BT_DBG("");
 994
 995         switch (adapter_state) {
 996         case BT_ACTIVATING:
 997         {
 998                 BT_INFO("Adapter is currently in activating state, state [%d]",
 999                                 adapter_state);
1000                 if (enable) {
1001                         return BLUETOOTH_ERROR_IN_PROGRESS;
1002                 } else {
1003                         if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED ||
1004                                         adapter_discovery_state == ADAPTER_DISCOVERY_STARTING) {
1005                                 /*TODO Stop Discovery*/
1006                                 if (result != OAL_STATUS_SUCCESS)
1007                                         BT_ERR("Discover stop failed: %d", result);
1008                                 __bt_adapter_update_discovery_status(FALSE);
1009                         }
1010                         result = adapter_disable();
1011                         if (result != OAL_STATUS_SUCCESS) {
1012                                 BT_ERR("adapter_enable failed: [%d]", result);
1013                                 result = BLUETOOTH_ERROR_INTERNAL;
1014                                 /*TODO: perform if anything more needs to be done to handle failure */
1015                         } else {
1016                                 /* TODO: To be handled */
1017                                 __bt_adapter_state_set_status(BT_DEACTIVATING);
1018                                 result = BLUETOOTH_ERROR_NONE;
1019                         }
1020                 }
1021                 break;
1022         }
1023         case BT_ACTIVATED:
1024         {
1025                 BT_INFO("Adapter is currently in activated state, state [%d]",
1026                                 adapter_state);
1027                 if (enable) {
1028                         return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1029                 } else {
1030                         if (adapter_discovery_state == ADAPTER_DISCOVERY_STARTED ||
1031                                         adapter_discovery_state == ADAPTER_DISCOVERY_STARTING) {
1032                                 /*TODO Stop Discovery*/
1033                                 if (result != OAL_STATUS_SUCCESS)
1034                                         BT_ERR("Discover stop failed: %d", result);
1035                                 __bt_adapter_update_discovery_status(FALSE);
1036                         }
1037                         result = adapter_disable();
1038                         if (result != OAL_STATUS_SUCCESS) {
1039                                 BT_ERR("adapter_enable failed: [%d]", result);
1040                                 result = BLUETOOTH_ERROR_INTERNAL;
1041                                 /*TODO: perform if anything more needs to be done to handle failure */
1042                         } else {
1043                                 /* TODO: To be handled */
1044                                 __bt_adapter_state_set_status(BT_DEACTIVATING);
1045                                 result = BLUETOOTH_ERROR_NONE;
1046                         }
1047                 }
1048                 break;
1049         }
1050         case BT_DEACTIVATING:
1051         {
1052                 BT_INFO("Adapter is currently in deactivating state, state [%d]",
1053                                 adapter_state);
1054                 if (!enable) {
1055                         return BLUETOOTH_ERROR_IN_PROGRESS;
1056
1057                 } else {
1058                         result = adapter_enable();
1059                         if (result != OAL_STATUS_SUCCESS) {
1060                                 BT_ERR("adapter_enable failed: [%d]", result);
1061                                 adapter_disable();
1062                                 result = BLUETOOTH_ERROR_INTERNAL;
1063                                 /*TODO: perform if anything more needs to be done to handle failure */
1064                         } else {
1065                                 /* TODO: To be handled */
1066                                 __bt_adapter_state_set_status(BT_ACTIVATING);
1067                                 result = BLUETOOTH_ERROR_NONE;
1068                         }
1069                 }
1070                 break;
1071         }
1072         case BT_DEACTIVATED:
1073         {
1074                 BT_INFO("Adapter is currently in deactivated state, state [%d]",
1075                                 adapter_state);
1076                 if (!enable) {
1077                         return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1078                 } else {
1079                         result = adapter_enable();
1080                         if (result != OAL_STATUS_SUCCESS) {
1081                                 BT_ERR("adapter_enable failed: [%d]", result);
1082                                 adapter_disable();
1083                                 result = BLUETOOTH_ERROR_INTERNAL;
1084                                 /*TODO: perform if anything more needs to be done to handle failure */
1085                         } else {
1086                                 /* TODO: To be handled */
1087                                 __bt_adapter_state_set_status(BT_ACTIVATING);
1088                                 result = BLUETOOTH_ERROR_NONE;
1089                         }
1090                 }
1091                 break;
1092         }
1093         }
1094         if (enable && result == BLUETOOTH_ERROR_NONE) {
1095                 /* Adapter enable request is successful, setup event handlers */
1096                 _bt_service_register_event_handler_callback(
1097                                 BT_ADAPTER_MODULE, __bt_adapter_event_handler);
1098                 _bt_device_state_handle_callback_set_request();
1099         }
1100         return result;
1101 }
1102
1103 static int __bt_adapter_state_discovery_request(gboolean enable)
1104 {
1105         int result = BLUETOOTH_ERROR_NONE;
1106
1107         BT_DBG("+");
1108         switch (adapter_discovery_state) {
1109         case ADAPTER_DISCOVERY_STARTED: {
1110                 BT_INFO("Adapter is currently in discovery started state, state [%d]",
1111                                 adapter_discovery_state);
1112                 if (enable) {
1113                         return BLUETOOTH_ERROR_IN_PROGRESS;
1114                 } else {
1115                         result = adapter_stop_inquiry();
1116                         if (result != OAL_STATUS_SUCCESS) {
1117                                 BT_ERR("Discover stop failed: %d", result);
1118                                 result = BLUETOOTH_ERROR_INTERNAL;
1119                         } else {
1120                                 BT_ERR("Stop Discovery Triggered successfully");
1121                                 __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STOPPING);
1122                                 result = BLUETOOTH_ERROR_NONE;
1123                         }
1124                 }
1125                 break;
1126         }
1127         case ADAPTER_DISCOVERY_STARTING: {
1128                 BT_INFO("Adapter is currently in discovery starting state, state [%d]",
1129                                 adapter_discovery_state);
1130                 if (enable) {
1131                         return BLUETOOTH_ERROR_IN_PROGRESS;
1132                 } else {
1133                         result = adapter_stop_inquiry();
1134                         if (result != OAL_STATUS_SUCCESS) {
1135                                 BT_ERR("Discover stop failed: %d", result);
1136                                 result = BLUETOOTH_ERROR_INTERNAL;
1137                         } else {
1138                                 BT_ERR("Stop Discovery Triggered successfully");
1139                                 __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STOPPING);
1140                                 result = BLUETOOTH_ERROR_NONE;
1141                         }
1142                 }
1143                 break;
1144         }
1145         case ADAPTER_DISCOVERY_STOPPED: {
1146                 BT_INFO("Adapter is currently in discovery stopped state, state [%d]",
1147                                 adapter_discovery_state);
1148                 if (!enable)
1149                         return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1150                 else {
1151                         result = adapter_start_inquiry();
1152                 if (result != OAL_STATUS_SUCCESS) {
1153                                 BT_ERR("Start Discovery failed: %d", result);
1154                                 result = BLUETOOTH_ERROR_INTERNAL;
1155                         } else {
1156                                 BT_ERR("Start Discovery Triggered successfully");
1157                         __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STARTING);
1158                                 result = BLUETOOTH_ERROR_NONE;
1159                         }
1160                 }
1161                 break;
1162         }
1163         case ADAPTER_DISCOVERY_STOPPING: {
1164                 BT_INFO("Adapter is currently in discovery stopping state, state [%d]",
1165                                 adapter_discovery_state);
1166                 if (!enable)
1167                         return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1168                 else {
1169                         result = adapter_start_inquiry();
1170                         if (result != OAL_STATUS_SUCCESS) {
1171                                 BT_ERR("Start Discovery failed: %d", result);
1172                                 result = BLUETOOTH_ERROR_INTERNAL;
1173                         } else {
1174                                 BT_ERR("Start Discovery Triggered successfully");
1175                         __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STARTING);
1176                                 result = BLUETOOTH_ERROR_NONE;
1177                         }
1178                 }
1179                 break;
1180         }
1181         }
1182
1183         BT_DBG("-");
1184         return result;
1185 }
1186
1187 static void __bt_adapter_discovery_state_change_callback(int bt_discovery_status)
1188 {
1189         BT_INFO("__bt_adapter_discovery_state_change_callback: status [%d]", bt_discovery_status);
1190         GVariant *param = NULL;
1191         int result = BLUETOOTH_ERROR_NONE;
1192
1193         switch (bt_discovery_status) {
1194         case ADAPTER_DISCOVERY_STOPPED:
1195         {
1196                 __bt_adapter_update_discovery_status(bt_discovery_status);
1197                 param = g_variant_new("(i)", result);
1198                 _bt_send_event(BT_ADAPTER_EVENT,
1199                                 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
1200                                 param);
1201                 break;
1202         }
1203         case ADAPTER_DISCOVERY_STARTED:
1204         {
1205                 __bt_adapter_update_discovery_status(bt_discovery_status);
1206                 param = g_variant_new("(i)", result);
1207                 _bt_send_event(BT_ADAPTER_EVENT,
1208                                 BLUETOOTH_EVENT_DISCOVERY_STARTED,
1209                                 param);
1210                 break;
1211         }
1212         default:
1213                 BT_ERR("Incorrect Bluetooth adapter Discovery state changed status");
1214         }
1215 }
1216
1217 #ifdef TIZEN_MOBILE
1218 static void __bt_set_visible_mode(void)
1219 {
1220         int timeout = 0;
1221
1222         if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
1223                 BT_ERR("Fail to get the timeout value");
1224
1225 #ifdef TIZEN_DPM_ENABLE
1226         if (timeout == -1 ||
1227                         _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
1228                 if (_bt_set_discoverable_mode(
1229                                         BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
1230                                         timeout) != BLUETOOTH_ERROR_NONE) {
1231                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
1232                                 BT_ERR("Set vconf failed");
1233                 }
1234         } else {
1235                 if (_bt_set_discoverable_mode(
1236                                         BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
1237                                         timeout) != BLUETOOTH_ERROR_NONE) {
1238                         BT_ERR("Set connectable mode failed");
1239                 }
1240         }
1241 #else
1242         if (timeout == -1) {
1243                 if (_bt_set_discoverable_mode(
1244                                         BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
1245                                         timeout) != BLUETOOTH_ERROR_NONE) {
1246                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
1247                                 BT_ERR("Set vconf failed");
1248                 }
1249         } else {
1250                 if (_bt_set_discoverable_mode(
1251                                         BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
1252                                         timeout) != BLUETOOTH_ERROR_NONE) {
1253                         BT_ERR("Set connectable mode failed");
1254                 }
1255         }
1256 #endif
1257 }
1258 #endif
1259
1260 static void __bt_set_local_name(void)
1261 {
1262         char *phone_name = NULL;
1263         char *ptr = NULL;
1264
1265         phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1266
1267         if (!phone_name)
1268                 return;
1269
1270         if (strlen(phone_name) != 0) {
1271                 if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
1272                         *ptr = '\0';
1273
1274                 _bt_set_local_name(phone_name);
1275         }
1276         free(phone_name);
1277 }