bt-service/bt-service-adapter.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <gio/gio.h>
  20 #include <glib.h>
  21 #include <dlog.h>
  22 #include <string.h>
  23 #include <vconf.h>
  24 #include <syspopup_caller.h>
  25 #include <aul.h>
  26 #include <dbus/dbus-glib.h>
  27 #include <dbus/dbus.h>
  28 #include <bundle.h>
  29 #include <eventsystem.h>
  30 #include <bundle_internal.h>
  31
  32 #include "alarm.h"
  33 #include "bluetooth-api.h"
  34 #include "bt-internal-types.h"
  35 #include "bt-service-common.h"
  36 #include "bt-service-event.h"
  37 #include "bt-service-adapter.h"
  38 #include "bt-service-util.h"
  39 #include "bt-service-network.h"
  40 #include "bt-service-obex-server.h"
  41 #include "bt-service-opp-client.h"
  42 #include "bt-service-agent.h"
  43 #include "bt-service-main.h"
  44 #include "bt-service-avrcp.h"
  45 #include "bt-service-device.h"
  46 #ifdef TIZEN_DPM_ENABLE
  47 #include "bt-service-dpm.h"
  48 #endif
  49
  50 typedef struct {
  51         guint event_id;
  52         int timeout;
  53         time_t start_time;
  54         int alarm_id;
  55 } bt_adapter_timer_t;
  56
  57 bt_adapter_timer_t visible_timer = {0, };
  58
  59 typedef struct {
  60         alarm_id_t alarm_id;
  61         bt_set_alarm_cb callback;
  62         void *user_data;
  63 } bt_service_alarm_t;
  64
  65 typedef struct {
  66         gboolean is_alarm_initialized;
  67         GList *g_alarm_list;
  68 } bt_service_alarm_mgr_t;
  69
  70 static bt_service_alarm_mgr_t alarm_mgr = {0, };
  71
  72 static gboolean is_discovering;
  73 static gboolean cancel_by_user;
  74 static bt_status_t adapter_status = BT_DEACTIVATED;
  75 static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
  76 static gboolean is_le_intended = FALSE;
  77 static void *adapter_agent = NULL;
  78 static GDBusProxy *core_proxy = NULL;
  79 static guint timer_id = 0;
  80 static guint le_timer_id = 0;
  81 static gboolean is_recovery_mode;
  82
  83 static uint status_reg_id;
  84
  85 #define BT_CORE_NAME "org.projectx.bt_core"
  86 #define BT_CORE_PATH "/org/projectx/bt_core"
  87 #define BT_CORE_INTERFACE "org.projectx.btcore"
  88
  89 #define BT_DISABLE_TIME 500 /* 500 ms */
  90
  91 static int alarm_cb(alarm_id_t alarm_id, void* user_param);
  92 static void alarm_data_free(void *data);
  93
  94 GDBusProxy *_bt_init_core_proxy(void)
  95 {
  96         GDBusProxy *proxy;
  97         GDBusConnection *conn;
  98
  99         conn = _bt_get_system_gconn();
 100         if (!conn)
 101                 return NULL;
 102
 103         proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
 104                                         NULL,
 105                                         BT_CORE_NAME,
 106                                         BT_CORE_PATH,
 107                                         BT_CORE_INTERFACE,
 108                                         NULL, NULL);
 109
 110         if (!proxy)
 111                 return NULL;
 112
 113         core_proxy = proxy;
 114
 115         return proxy;
 116 }
 117
 118 static GDBusProxy *__bt_get_core_proxy(void)
 119 {
 120        return (core_proxy) ? core_proxy : _bt_init_core_proxy();
 121 }
 122
 123 static gboolean __bt_is_factory_test_mode(void)
 124 {
 125         int mode = 0;
 126
 127         if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
 128                 BT_ERR("Get the DUT Mode fail");
 129                 return TRUE;
 130         }
 131
 132         if (mode != FALSE) {
 133                 BT_INFO("DUT Test Mode !!");
 134                 return TRUE;
 135         }
 136
 137         return FALSE;
 138 }
 139
 140 static gboolean __bt_timeout_handler(gpointer user_data)
 141 {
 142         int result = BLUETOOTH_ERROR_NONE;
 143         time_t current_time;
 144         int time_diff;
 145
 146         /* Take current time */
 147         time(&current_time);
 148         time_diff = difftime(current_time, visible_timer.start_time);
 149
 150         /* Send event to application */
 151         _bt_send_event(BT_ADAPTER_EVENT,
 152                         BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 153                         g_variant_new("(in)", result, time_diff));
 154
 155         if (visible_timer.timeout <= time_diff) {
 156                 g_source_remove(visible_timer.event_id);
 157                 visible_timer.event_id = 0;
 158                 visible_timer.timeout = 0;
 159
 160 #ifndef TIZEN_PROFILE_WEARABLE
 161                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
 162                         BT_ERR("Set vconf failed\n");
 163 #endif
 164                 return FALSE;
 165         }
 166
 167         return TRUE;
 168 }
 169
 170 static int __bt_visibility_alarm_cb(alarm_id_t alarm_id, void* user_param)
 171 {
 172
 173         int result = BLUETOOTH_ERROR_NONE;
 174         int timeout = 0;
 175
 176         if (alarm_id != visible_timer.alarm_id)
 177                 return 0;
 178
 179         if (visible_timer.event_id) {
 180                 _bt_send_event(BT_ADAPTER_EVENT,
 181                                 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 182                                 g_variant_new("(in)", result, timeout));
 183                 g_source_remove(visible_timer.event_id);
 184                 visible_timer.event_id = 0;
 185                 visible_timer.timeout = 0;
 186
 187 #ifndef TIZEN_PROFILE_WEARABLE
 188                 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
 189                         BT_ERR("Set vconf failed\n");
 190 #endif
 191         }
 192         /* Switch Off visibility in Bluez */
 193         _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
 194         visible_timer.alarm_id = 0;
 195         return 0;
 196 }
 197
 198 static void __bt_visibility_alarm_remove()
 199 {
 200         if (visible_timer.event_id > 0) {
 201                 g_source_remove(visible_timer.event_id);
 202                 visible_timer.event_id = 0;
 203         }
 204
 205         if (visible_timer.alarm_id > 0) {
 206                 _bt_service_remove_alarm(visible_timer.alarm_id);
 207                 visible_timer.alarm_id = 0;
 208         }
 209 }
 210
 211 int __bt_set_visible_time(int timeout)
 212 {
 213         int result;
 214         alarm_id_t alarm_id;
 215
 216         __bt_visibility_alarm_remove();
 217
 218         visible_timer.timeout = timeout;
 219
 220 #ifndef TIZEN_PROFILE_WEARABLE
 221 #ifdef TIZEN_DPM_ENABLE
 222         if (_bt_dpm_get_bluetooth_limited_discoverable_state() != DPM_RESTRICTED) {
 223 #endif
 224         if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
 225                 BT_ERR("Set vconf failed");
 226 #ifdef TIZEN_DPM_ENABLE
 227         }
 228 #endif
 229 #endif
 230
 231
 232         if (timeout <= 0)
 233                 return BLUETOOTH_ERROR_NONE;
 234
 235         result = _bt_service_set_alarm(visible_timer.timeout,
 236                                                 __bt_visibility_alarm_cb, NULL, &alarm_id);
 237         if (result != BLUETOOTH_ERROR_NONE)
 238                 return BLUETOOTH_ERROR_INTERNAL;
 239         visible_timer.alarm_id = alarm_id;
 240         /* Take start time */
 241         time(&(visible_timer.start_time));
 242         visible_timer.event_id = g_timeout_add_seconds(1,
 243                                 __bt_timeout_handler, NULL);
 244
 245         return BLUETOOTH_ERROR_NONE;
 246 }
 247
 248 static void __bt_get_service_list(GVariant *value, bluetooth_device_info_t *dev)
 249 {
 250         int i = 0;
 251         char **parts;
 252         GVariantIter *iter;
 253         gchar *uuid = NULL;
 254
 255         ret_if(value == NULL);
 256         ret_if(dev == NULL);
 257
 258         dev->service_index = 0;
 259
 260         g_variant_get(value, "as", &iter);
 261         while (g_variant_iter_loop(iter, "s", &uuid)) {
 262                 g_strlcpy(dev->uuids[i], uuid, BLUETOOTH_UUID_STRING_MAX);
 263                 parts = g_strsplit(uuid, "-", -1);
 264
 265                 if (parts == NULL || parts[0] == NULL) {
 266                         g_free(uuid);
 267                         break;
 268                 }
 269
 270                 dev->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
 271                 g_strfreev(parts);
 272
 273                 dev->service_index++;
 274                 i++;
 275         }
 276         g_variant_iter_free(iter);
 277 }
 278
 279 static int __bt_get_bonded_device_info(gchar *device_path,
 280                 bluetooth_device_info_t *dev_info)
 281 {
 282         GError *error = NULL;
 283         GDBusProxy *device_proxy;
 284         gchar *address = NULL;
 285         gchar *name = NULL;
 286         unsigned int cod = 0;
 287         gint rssi = 0;
 288         gboolean trust = FALSE;
 289         gboolean paired = FALSE;
 290         guchar connected = 0;
 291         GByteArray *manufacturer_data = NULL;
 292         int ret;
 293         GDBusConnection *conn;
 294         GVariant *result;
 295         GVariantIter *property_iter;
 296         const gchar *key;
 297         GVariant *value;
 298         guint8 char_value;
 299         GVariantIter *char_value_iter;
 300
 301         BT_CHECK_PARAMETER(device_path, return);
 302         BT_CHECK_PARAMETER(dev_info, return);
 303
 304         conn = _bt_get_system_gconn();
 305         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 306
 307         device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
 308                                         NULL,
 309                                         BT_BLUEZ_NAME,
 310                                         device_path,
 311                                         BT_PROPERTIES_INTERFACE,
 312                                         NULL, NULL);
 313
 314         retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 315
 316         result = g_dbus_proxy_call_sync(device_proxy,
 317                                 "GetAll",
 318                                 g_variant_new("(s)", BT_DEVICE_INTERFACE),
 319                                 G_DBUS_CALL_FLAGS_NONE,
 320                                 -1,
 321                                 NULL,
 322                                 &error);
 323
 324         if (!result) {
 325                 BT_ERR("Error occured in Proxy call");
 326                 if (error != NULL) {
 327                         BT_ERR("Error occured in Proxy call (Error: %s)", error->message);
 328                         g_clear_error(&error);
 329                 }
 330                 g_object_unref(device_proxy);
 331                 return BLUETOOTH_ERROR_INTERNAL;
 332         }
 333
 334         g_object_unref(device_proxy);
 335
 336         g_variant_get(result, "(a{sv})", &property_iter);
 337
 338         while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
 339                 if (!g_strcmp0(key, "Paired")) {
 340                         paired = g_variant_get_boolean(value);
 341                 } else if (!g_strcmp0(key, "Address")) {
 342                         g_variant_get(value, "s", &address);
 343                 } else if (!g_strcmp0(key, "Alias")) {
 344                         g_variant_get(value, "s", &name);
 345                 } else if (!g_strcmp0(key, "Name")) {
 346                         if (!name)
 347                                 g_variant_get(value, "s", &name);
 348                 } else if(!g_strcmp0(key, "IsAliasSet")) {
 349                         dev_info->is_alias_set = g_variant_get_boolean(value);
 350                 } else if (!g_strcmp0(key, "Class")) {
 351                         cod = g_variant_get_uint32(value);
 352                 } else if (!g_strcmp0(key, "Connected")) {
 353                         connected = g_variant_get_byte(value);
 354                 } else if (!g_strcmp0(key, "Trusted")) {
 355                         trust = g_variant_get_boolean(value);
 356                 } else if (!g_strcmp0(key, "RSSI")) {
 357                         rssi = g_variant_get_int16(value);
 358                 } else if (!g_strcmp0(key, "UUIDs")) {
 359                         __bt_get_service_list(value, dev_info);
 360                 } else if (!g_strcmp0(key, "ManufacturerDataLen")) {
 361                         dev_info->manufacturer_data.data_len = g_variant_get_uint16(value);
 362                 } else if (!g_strcmp0(key, "ManufacturerData")) {
 363                         manufacturer_data = g_byte_array_new();
 364                         g_variant_get(value, "ay", &char_value_iter);
 365                         while (g_variant_iter_loop(char_value_iter, "y",  &char_value)) {
 366                                 g_byte_array_append(manufacturer_data, &char_value, 1);
 367                         }
 368                         g_variant_iter_free(char_value_iter);
 369
 370                         if (manufacturer_data) {
 371                                 if (manufacturer_data->len > 0) {
 372                                         memcpy(dev_info->manufacturer_data.data, manufacturer_data->data,
 373                                                 manufacturer_data->len);
 374                                 }
 375                         }
 376                         g_byte_array_free(manufacturer_data, TRUE);
 377                 }
 378         }
 379         g_variant_iter_free(property_iter);
 380
 381         BT_DBG("trust: %d, paired: %d", trust, paired);
 382
 383         g_variant_unref(result);
 384
 385         if ((paired == FALSE) && (trust == FALSE)) {
 386                 g_free(address);
 387                 g_free(name);
 388                 return BLUETOOTH_ERROR_NOT_PAIRED;
 389         }
 390
 391         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
 392                                         address);
 393
 394         _bt_divide_device_class(&dev_info->device_class, cod);
 395
 396         g_strlcpy(dev_info->device_name.name, name,
 397                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
 398
 399         dev_info->rssi = rssi;
 400         dev_info->trust = trust;
 401         dev_info->paired = paired;
 402         dev_info->connected = connected;
 403         ret = BLUETOOTH_ERROR_NONE;
 404         g_free(address);
 405         g_free(name);
 406
 407         return ret;
 408 }
 409
 410 void _bt_set_discovery_status(gboolean mode)
 411 {
 412         is_discovering = mode;
 413 }
 414
 415 void _bt_set_cancel_by_user(gboolean value)
 416 {
 417         cancel_by_user = value;
 418 }
 419
 420 gboolean _bt_get_cancel_by_user(void)
 421 {
 422         return cancel_by_user;
 423 }
 424
 425 void _bt_adapter_set_status(bt_status_t status)
 426 {
 427         BT_INFO("adapter_status changed [%d] -> [%d]", adapter_status, status);
 428         adapter_status = status;
 429 }
 430
 431 bt_status_t _bt_adapter_get_status(void)
 432 {
 433         return adapter_status;
 434 }
 435
 436 void _bt_adapter_set_le_status(bt_le_status_t status)
 437 {
 438         BT_INFO("adapter_le_status changed [%d] -> [%d]", adapter_le_status, status);
 439         adapter_le_status = status;
 440 }
 441
 442 bt_le_status_t _bt_adapter_get_le_status(void)
 443 {
 444         return adapter_le_status;
 445 }
 446
 447
 448 void _bt_set_le_intended_status(gboolean value)
 449 {
 450         is_le_intended = value;
 451 }
 452
 453 static void __bt_phone_name_changed_cb(keynode_t *node, void *data)
 454 {
 455         char *phone_name = NULL;
 456         char *ptr = NULL;
 457
 458         if (node == NULL)
 459                 return;
 460
 461         if (vconf_keynode_get_type(node) == VCONF_TYPE_STRING) {
 462                 phone_name = vconf_keynode_get_str(node);
 463
 464                 if (phone_name && strlen(phone_name) != 0) {
 465                         if (!g_utf8_validate(phone_name, -1,
 466                                                         (const char **)&ptr))
 467                                 *ptr = '\0';
 468
 469                         _bt_set_local_name(phone_name);
 470                 }
 471         }
 472 }
 473
 474 static void __bt_set_local_name(void)
 475 {
 476         bluetooth_device_name_t local_name;
 477         char *phone_name = NULL;
 478         char *ptr = NULL;
 479         char *temp = NULL;
 480
 481         if (_bt_get_local_name(&local_name) != BLUETOOTH_ERROR_NONE ||
 482                 (temp = strstr(local_name.name, "BlueZ")) != NULL) {
 483                 phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 484
 485                 if (!phone_name)
 486                         return;
 487
 488                 if (strlen(phone_name) != 0) {
 489                         if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
 490                                 *ptr = '\0';
 491
 492                         _bt_set_local_name(phone_name);
 493                 }
 494                 free(phone_name);
 495         }
 496 }
 497
 498 static int __bt_set_enabled(void)
 499 {
 500         int adapter_status = BT_ADAPTER_DISABLED;
 501         int result = BLUETOOTH_ERROR_NONE;
 502
 503         if (timer_id > 0) {
 504                 BT_DBG("g_source is removed");
 505                 g_source_remove(timer_id);
 506                 timer_id = 0;
 507         }
 508
 509         _bt_check_adapter(&adapter_status);
 510
 511         if (adapter_status == BT_ADAPTER_DISABLED) {
 512                 BT_ERR("Bluetoothd is not running");
 513                 return BLUETOOTH_ERROR_INTERNAL;
 514         }
 515
 516 #ifdef TIZEN_PROFILE_MOBILE
 517         /* BT setting UI will control Mobile's visible mode. So in the FRWK...set the visible mode as off: */
 518         if (_bt_set_discoverable_mode(
 519                 BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0) != BLUETOOTH_ERROR_NONE)
 520                         BT_ERR("Set connectable mode failed");
 521 #else
 522 #ifdef TIZEN_TV
 523         if (_bt_set_discoverable_mode(
 524                 BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0) != BLUETOOTH_ERROR_NONE)
 525                         BT_ERR("Fail to set discoverable mode");
 526 #endif
 527 #endif
 528
 529         /* Update Bluetooth Status to notify other modules */
 530         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
 531                 BT_ERR("Set vconf failed\n");
 532
 533         if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
 534                 BT_ERR("Set vconf failed\n");
 535
 536         if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
 537                                                 EVT_VAL_BT_ON) != ES_R_OK)
 538                 BT_ERR("Fail to set value");
 539
 540         /* Send enabled event to API */
 541         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
 542                                 g_variant_new("(i)", result));
 543
 544 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
 545         _bt_audio_start_auto_connect(FALSE);
 546 #endif
 547
 548         __bt_set_local_name();
 549         _bt_set_discovery_status(FALSE);
 550
 551         return BLUETOOTH_ERROR_NONE;
 552 }
 553
 554 void _bt_set_disabled(int result)
 555 {
 556         int power_off_status = 0;
 557         int ret;
 558         int ret_pm_ignore;
 559         int pm_ignore_mode = 0;
 560
 561         ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
 562         BT_DBG("ret : %d, power_off_status : %d", ret, power_off_status);
 563
 564         ret_pm_ignore = vconf_get_int(VCONFKEY_PM_KEY_IGNORE, &pm_ignore_mode);
 565
 566         /* Update the vconf BT status in normal Deactivation case only */
 567         if (ret == 0 && power_off_status == VCONFKEY_SYSMAN_POWER_OFF_NONE &&
 568                 ret_pm_ignore == 0 && pm_ignore_mode != VCONFKEY_PM_KEY_LOCK) {
 569
 570                 BT_DBG("Update vconf for BT normal Deactivation");
 571
 572                 if (result == BLUETOOTH_ERROR_TIMEOUT)
 573                         if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 1) != 0)
 574                                 BT_ERR("Set vconf failed");
 575
 576                 /* Update Bluetooth Status to notify other modules */
 577                 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
 578                         BT_ERR("Set vconf failed");
 579
 580                 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
 581                                                         EVT_VAL_BT_OFF) != ES_R_OK)
 582                         BT_ERR("Fail to set value");
 583         }
 584
 585         if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
 586                 BT_ERR("Set vconf failed\n");
 587
 588         _bt_cancel_queued_transfers();
 589         _bt_adapter_set_status(BT_DEACTIVATED);
 590         _bt_set_discovery_status(FALSE);
 591
 592 #ifndef USB_BLUETOOTH
 593         if (_bt_adapter_get_le_status() != BT_LE_DEACTIVATED) {
 594 #endif
 595                 /* Send disabled event */
 596                 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
 597                                 g_variant_new("(i)", result));
 598 #ifndef USB_BLUETOOTH
 599         }
 600 #endif
 601
 602         BT_INFO("Adapter disabled");
 603 }
 604
 605 static int __bt_set_le_enabled(void)
 606 {
 607         BT_DBG("+");
 608         int result = BLUETOOTH_ERROR_NONE;
 609         bt_status_t status;
 610
 611         /* Update Bluetooth Status to notify other modules */
 612         if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_ON) != 0)
 613                 BT_ERR("Set vconf failed\n");
 614
 615         if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
 616                                                 EVT_VAL_BT_LE_ON) != ES_R_OK)
 617                 BT_ERR("Fail to set value");
 618
 619         /* Send enabled event to API */
 620         /*
 621         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
 622                                 DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 623         */
 624         status = _bt_adapter_get_status();
 625         if (status == BT_DEACTIVATED) {
 626                 BT_INFO("BREDR is off, turn off PSCAN");
 627                 _bt_set_connectable(FALSE);
 628         }
 629         if (le_timer_id > 0) {
 630                 g_source_remove(le_timer_id);
 631                 le_timer_id = 0;
 632         }
 633
 634         /* Send enabled event to API */
 635         _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_ENABLED,
 636                                 g_variant_new("(i)", result));
 637
 638         __bt_set_local_name();
 639
 640         BT_DBG("-");
 641         return BLUETOOTH_ERROR_NONE;
 642 }
 643
 644 void _bt_set_le_disabled(int result)
 645 {
 646         int power_off_status;
 647         int ret;
 648
 649         ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
 650         BT_DBG("ret : %d", ret);
 651         BT_DBG("power_off_status : %d", power_off_status);
 652
 653         /* Update Bluetooth Status to notify other modules */
 654         BT_DBG("Update vconf for BT LE normal Deactivation");
 655         if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_OFF) != 0)
 656                 BT_ERR("Set vconf failed\n");
 657         _bt_adapter_set_le_status(BT_LE_DEACTIVATED);
 658
 659         if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
 660                                                 EVT_VAL_BT_LE_OFF) != ES_R_OK)
 661                 BT_ERR("Fail to set value");
 662
 663         /* Send disabled event */
 664         _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_DISABLED,
 665                         g_variant_new_int32(result));
 666 }
 667
 668 void *_bt_get_adapter_agent(void)
 669 {
 670         return adapter_agent;
 671 }
 672
 673 int _bt_enable_core(void)
 674 {
 675         GDBusProxy *proxy;
 676         GVariant *result;
 677         GError *error = NULL;
 678
 679         proxy = __bt_get_core_proxy();
 680         retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
 681
 682         /* Clean up the process */
 683         result = g_dbus_proxy_call_sync(proxy,
 684                                 "EnableCore",
 685                                 NULL,
 686                                 G_DBUS_CALL_FLAGS_NONE,
 687                                 -1,
 688                                 NULL,
 689                                 &error);
 690
 691         if (!result) {
 692                 if (error != NULL) {
 693                         BT_ERR("Bt core call failed(Error: %s)", error->message);
 694                         g_clear_error(&error);
 695                 } else
 696                         BT_ERR("Bt core call failed");
 697                 return BLUETOOTH_ERROR_INTERNAL;
 698         }
 699
 700         g_variant_unref(result);
 701         return BLUETOOTH_ERROR_NONE;
 702 }
 703
 704 #if defined(TIZEN_FEATURE_FLIGHTMODE_ENABLED) || (!defined(TIZEN_PROFILE_WEARABLE))
 705 static void __bt_service_flight_ps_mode_cb(keynode_t *node, void *data)
 706 {
 707         gboolean flight_mode = FALSE;
 708         int power_saving_mode = 0;
 709         int type;
 710
 711         DBG_SECURE("key=%s", vconf_keynode_get_name(node));
 712         type = vconf_keynode_get_type(node);
 713         if (type == VCONF_TYPE_BOOL) {
 714                 flight_mode = vconf_keynode_get_bool(node);
 715                 if (flight_mode != TRUE) {
 716                         BT_ERR("Ignore the event");
 717                         return;
 718                 }
 719         } else if (type == VCONF_TYPE_INT) {
 720                 power_saving_mode = vconf_keynode_get_int(node);
 721                 if (power_saving_mode != 2) {
 722                         BT_ERR("Ignore the event");
 723                         return;
 724                 }
 725         } else {
 726                 BT_ERR("Invaild vconf key type : %d", type);
 727                 return;
 728         }
 729
 730         _bt_enable_core();
 731 }
 732 #endif
 733
 734 void _bt_service_register_vconf_handler(void)
 735 {
 736         BT_DBG("+");
 737
 738 #ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
 739         if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
 740                         (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
 741                 BT_ERR("Unable to register key handler");
 742 #else
 743         BT_DBG("Telephony is disabled");
 744 #endif
 745
 746 #ifndef TIZEN_PROFILE_WEARABLE
 747         if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
 748                         (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
 749                 BT_ERR("Unable to register key handler");
 750 #endif
 751 }
 752
 753 void _bt_service_unregister_vconf_handler(void)
 754 {
 755         BT_DBG("+");
 756
 757 #ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
 758         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
 759                         (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
 760 #endif
 761
 762 #ifndef TIZEN_PROFILE_WEARABLE
 763         vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
 764                         (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
 765 #endif
 766 }
 767
 768 static void __bt_state_event_handler(const char *event_name, bundle *data, void *user_data)
 769 {
 770         const char *bt_status = NULL;
 771         const char *bt_le_status = NULL;
 772         BT_DBG("bt state set event(%s) received", event_name);
 773
 774         bt_status = bundle_get_val(data, EVT_KEY_BT_STATE);
 775         BT_DBG("bt_state: (%s)", bt_status);
 776
 777         bt_le_status = bundle_get_val(data, EVT_KEY_BT_LE_STATE);
 778         BT_DBG("bt_state: (%s)", bt_le_status);
 779 }
 780
 781 void _bt_handle_adapter_added(void)
 782 {
 783         BT_DBG("+");
 784         bt_status_t status;
 785         bt_le_status_t le_status;
 786         int ret;
 787 /*
 788         if (timer_id > 0) {
 789                 BT_DBG("g_source is removed");
 790                 g_source_remove(timer_id);
 791                 timer_id = 0;
 792         }
 793 */
 794
 795         status = _bt_adapter_get_status();
 796         le_status = _bt_adapter_get_le_status();
 797         BT_DBG("status : %d", status);
 798         BT_DBG("le_status : %d", le_status);
 799
 800 #ifndef USB_BLUETOOTH
 801         adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
 802         if (!adapter_agent) {
 803                 BT_ERR("Fail to register agent");
 804                 return;
 805         }
 806 #else
 807         if (adapter_agent == NULL) {
 808                 adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
 809                 if (!adapter_agent) {
 810                         BT_ERR("Fail to register agent");
 811                         return;
 812                 }
 813         }
 814 #endif
 815
 816         if (_bt_register_media_player() != BLUETOOTH_ERROR_NONE)
 817                 BT_ERR("Fail to register media player");
 818
 819         if (_bt_register_obex_server() != BLUETOOTH_ERROR_NONE)
 820                 BT_ERR("Fail to init obex server");
 821
 822 #ifdef TIZEN_BT_PAN_NAP_ENABLED
 823         if (_bt_network_activate() != BLUETOOTH_ERROR_NONE)
 824                 BT_ERR("Fail to activate network");
 825 #endif
 826
 827         /* add the vconf noti handler */
 828         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 829                                         __bt_phone_name_changed_cb, NULL);
 830         if (ret < 0)
 831                 BT_ERR("Unable to register key handler");
 832
 833         if (le_status == BT_LE_ACTIVATING ||
 834                  status == BT_ACTIVATING) {
 835                 __bt_set_le_enabled();
 836                 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
 837         }
 838
 839         if (status == BT_ACTIVATING) {
 840                 __bt_set_enabled();
 841                 _bt_adapter_set_status(BT_ACTIVATED);
 842         }
 843
 844         _bt_service_register_vconf_handler();
 845
 846         /* eventsystem */
 847         if (eventsystem_register_event(SYS_EVENT_BT_STATE, &status_reg_id,
 848                         (eventsystem_handler)__bt_state_event_handler, NULL) != ES_R_OK) {
 849                 BT_ERR("Fail to register system event");
 850         }
 851 }
 852
 853 void _bt_handle_adapter_removed(void)
 854 {
 855         int ret;
 856
 857         _bt_adapter_set_status(BT_DEACTIVATED);
 858
 859         __bt_visibility_alarm_remove();
 860
 861         if (alarm_mgr.is_alarm_initialized == TRUE) {
 862                 alarmmgr_fini();
 863                 alarm_mgr.is_alarm_initialized = FALSE;
 864                 g_list_free_full(alarm_mgr.g_alarm_list, alarm_data_free);
 865                 alarm_mgr.g_alarm_list = NULL;
 866         }
 867
 868 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
 869         _bt_audio_stop_auto_connect();
 870 #endif
 871
 872         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 873                                 (vconf_callback_fn)__bt_phone_name_changed_cb);
 874         if (0 != ret) {
 875                 ERR("vconf_ignore_key_changed failed\n");
 876         }
 877
 878 #ifndef USB_BLUETOOTH
 879         _bt_destroy_agent(adapter_agent);
 880         adapter_agent = NULL;
 881
 882         if (is_recovery_mode == TRUE) {
 883                 /* Send disabled event */
 884                 _bt_set_disabled(BLUETOOTH_ERROR_NONE);
 885
 886                 /* Will recover BT by bt-core, so set the mode as activating */
 887                 _bt_adapter_set_status(BT_ACTIVATING);
 888                 is_recovery_mode = FALSE;
 889         } else {
 890                 _bt_reliable_terminate_service(NULL);
 891         }
 892 #else
 893         _bt_set_disabled(BLUETOOTH_ERROR_NONE);
 894 #endif
 895
 896         if (eventsystem_unregister_event(status_reg_id) != ES_R_OK)
 897                 BT_ERR("Fail to unregister system event");
 898 }
 899
 900 static gboolean __bt_enable_timeout_cb(gpointer user_data)
 901 {
 902         GDBusProxy *proxy;
 903         GVariant *result;
 904         GError *error = NULL;
 905
 906         timer_id = 0;
 907
 908         retv_if(_bt_adapter_get_status() == BT_ACTIVATED, FALSE);
 909
 910         BT_ERR("EnableAdapter is failed");
 911
 912         proxy = __bt_get_core_proxy();
 913         if (!proxy)
 914                 return FALSE;
 915
 916         /* Clean up the process */
 917         result = g_dbus_proxy_call_sync(proxy,
 918                                 "DisableAdapter",
 919                                 NULL,
 920                                 G_DBUS_CALL_FLAGS_NONE,
 921                                 -1,
 922                                 NULL,
 923                                 &error);
 924
 925         if (!result) {
 926                 if (error != NULL) {
 927                         BT_ERR("Bt core call failed(Error: %s)", error->message);
 928                         g_clear_error(&error);
 929                 } else {
 930                         BT_ERR("Bt core call failed");
 931                 }
 932                 return FALSE;
 933         }
 934
 935         g_variant_unref(result);
 936         _bt_set_disabled(BLUETOOTH_ERROR_TIMEOUT);
 937
 938 #ifndef USB_BLUETOOTH
 939         _bt_terminate_service(NULL);
 940 #endif
 941
 942         return FALSE;
 943 }
 944
 945 static gboolean __bt_enable_le_timeout_cb(gpointer user_data)
 946 {
 947         GDBusProxy *proxy;
 948         GVariant *result;
 949         GError *error = NULL;
 950
 951         le_timer_id = 0;
 952
 953         retv_if(_bt_adapter_get_le_status() == BT_LE_ACTIVATED, FALSE);
 954
 955         BT_ERR("EnableAdapterLE is failed");
 956
 957         proxy = __bt_get_core_proxy();
 958         if (!proxy)
 959                 return FALSE;
 960
 961         /* Clean up the process */
 962         result = g_dbus_proxy_call_sync(proxy,
 963                                 "DisableAdapterLe",
 964                                 NULL,
 965                                 G_DBUS_CALL_FLAGS_NONE,
 966                                 -1,
 967                                 NULL,
 968                                 &error);
 969
 970         if (!result) {
 971                 if (error != NULL) {
 972                         BT_ERR("Bt core call failed(Error: %s)", error->message);
 973                         g_clear_error(&error);
 974                 } else
 975                         BT_ERR("Bt core call failed");
 976                 return FALSE;
 977         }
 978
 979         g_variant_unref(result);
 980         _bt_adapter_set_le_status(BT_LE_DEACTIVATED);
 981
 982         _bt_set_le_disabled(BLUETOOTH_ERROR_TIMEOUT);
 983
 984         if (_bt_adapter_get_status() == BT_DEACTIVATED)
 985                 _bt_terminate_service(NULL);
 986
 987         return FALSE;
 988 }
 989
 990 void _bt_adapter_start_le_enable_timer(void)
 991 {
 992         if (le_timer_id > 0) {
 993                 g_source_remove(le_timer_id);
 994                 le_timer_id = 0;
 995         }
 996
 997         le_timer_id = g_timeout_add(BT_ENABLE_TIMEOUT,
 998                         __bt_enable_le_timeout_cb, NULL);
 999
1000         return;
1001 }
1002
1003 void _bt_adapter_start_enable_timer(void)
1004 {
1005         if (timer_id > 0) {
1006                 g_source_remove(timer_id);
1007                 timer_id = 0;
1008         }
1009
1010         timer_id = g_timeout_add(BT_ENABLE_TIMEOUT,
1011                         __bt_enable_timeout_cb, NULL);
1012
1013         return;
1014 }
1015
1016 #ifdef TIZEN_TV
1017 static gboolean __bt_adapter_enabled_cb(gpointer user_data)
1018 {
1019         BT_DBG("+");
1020
1021         __bt_set_enabled();
1022         _bt_adapter_set_status(BT_ACTIVATED);
1023
1024         return FALSE;
1025 }
1026 #endif
1027
1028 int _bt_enable_adapter(void)
1029 {
1030         GDBusProxy *proxy;
1031         GError *error = NULL;
1032         int ret;
1033         GVariant *result = NULL;
1034         bt_status_t status = _bt_adapter_get_status();
1035         bt_le_status_t le_status = _bt_adapter_get_le_status();
1036
1037         BT_DBG("");
1038
1039         if (status == BT_ACTIVATING) {
1040                 BT_ERR("Enabling in progress");
1041                 return BLUETOOTH_ERROR_IN_PROGRESS;
1042         }
1043
1044         if (status == BT_ACTIVATED) {
1045                 BT_ERR("Already enabled");
1046                 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1047         }
1048
1049         if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
1050                 BT_ERR("Disabling in progress");
1051                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1052         }
1053
1054         _bt_adapter_set_status(BT_ACTIVATING);
1055
1056 #ifdef TIZEN_TV
1057 {
1058         int adapter_status = BT_ADAPTER_DISABLED;
1059
1060         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
1061                 BT_ERR("Set vconf failed");
1062
1063         _bt_check_adapter(&adapter_status);
1064         if (adapter_status == BT_ADAPTER_ENABLED) {
1065                 g_idle_add(__bt_adapter_enabled_cb, NULL);
1066                 _bt_adapter_start_enable_timer();
1067                 return BLUETOOTH_ERROR_NONE;
1068         }
1069 }
1070 #endif
1071
1072         proxy = __bt_get_core_proxy();
1073         if (!proxy)
1074                 return BLUETOOTH_ERROR_INTERNAL;
1075
1076         if (le_status == BT_LE_ACTIVATED) {
1077                 BT_INFO("LE Already enabled. Just turn on PSCAN");
1078                 ret = _bt_set_connectable(TRUE);
1079                 if (ret == BLUETOOTH_ERROR_NONE) {
1080                         _bt_adapter_set_status(BT_ACTIVATED);
1081                 } else {
1082                         return BLUETOOTH_ERROR_INTERNAL;
1083                 }
1084         }
1085
1086         result = g_dbus_proxy_call_sync(proxy, "EnableAdapter",
1087                                          NULL,
1088                                          G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
1089                                          NULL, &error);
1090          if (error) {
1091                  BT_ERR("EnableAdapterLe failed: %s", error->message);
1092                 _bt_adapter_set_status(BT_DEACTIVATED);
1093                 g_clear_error(&error);
1094                 error = NULL;
1095                 result = g_dbus_proxy_call_sync(proxy,
1096                                 "DisableAdapter",
1097                                 NULL,
1098                                 G_DBUS_CALL_FLAGS_NONE,
1099                                 -1,
1100                                 NULL,
1101                                 &error);
1102
1103                 if (error != NULL) {
1104                                 BT_ERR("Bt core call failed(Error: %s)", error->message);
1105                                 g_clear_error(&error);
1106                 }
1107                 g_variant_unref(result);
1108 #ifndef USB_BLUETOOTH
1109                 /* Terminate myself */
1110                 g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
1111 #endif
1112                 return BLUETOOTH_ERROR_INTERNAL;
1113         }
1114         g_variant_unref(result);
1115         if (le_status == BT_LE_ACTIVATED) {
1116                 __bt_set_enabled();
1117         } else {
1118                 _bt_adapter_start_enable_timer();
1119         }
1120
1121         return BLUETOOTH_ERROR_NONE;
1122 }
1123
1124 static gboolean __bt_disconnect_all(void)
1125 {
1126         int i;
1127         GDBusConnection *conn;
1128         GDBusProxy *dev_proxy;
1129         gboolean ret = FALSE;
1130         GVariant *result;
1131         GError *error = NULL;
1132         GArray *device_list;
1133         bluetooth_device_info_t info;
1134         guint size;
1135         char *device_path = NULL;
1136         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1137
1138
1139         BT_DBG("");
1140
1141         conn = _bt_get_system_gconn();
1142
1143         device_list = g_array_new(FALSE, FALSE, sizeof(gchar));
1144
1145         if (_bt_get_bonded_devices(&device_list)
1146                                         != BLUETOOTH_ERROR_NONE) {
1147                 g_array_free(device_list, TRUE);
1148                 return FALSE;
1149         }
1150
1151         size = (device_list->len) / sizeof(bluetooth_device_info_t);
1152
1153         for (i = 0; i < size; i++) {
1154
1155                 info = g_array_index(device_list,
1156                                 bluetooth_device_info_t, i);
1157
1158                 if (info.connected != BLUETOOTH_CONNECTED_LINK_NONE) {
1159                         BT_DBG("Found Connected device");
1160                         _bt_convert_addr_type_to_string(address, info.device_address.addr);
1161                         device_path = _bt_get_device_object_path(address);
1162                         if (device_path == NULL)
1163                                 continue;
1164
1165                         BT_DBG("Disconnecting : %s", device_path);
1166
1167                         dev_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1168                                                         NULL,
1169                                                         BT_BLUEZ_NAME,
1170                                                         device_path,
1171                                                         BT_DEVICE_INTERFACE,
1172                                                         NULL, NULL);
1173
1174                         if (dev_proxy == NULL)
1175                                 continue;
1176
1177                         result = g_dbus_proxy_call_sync(dev_proxy,
1178                                                 "Disconnect",
1179                                                 NULL,
1180                                                 G_DBUS_CALL_FLAGS_NONE,
1181                                                 -1,
1182                                                 NULL,
1183                                                 &error);
1184
1185                         if (!result) {
1186                                 if (error != NULL) {
1187                                         BT_ERR("Disconnect call failed(Error: %s)", error->message);
1188                                         g_clear_error(&error);
1189                                 } else
1190                                         BT_ERR("Disconnect call failed");
1191                                 g_object_unref(dev_proxy);
1192                                 return FALSE;
1193                         }
1194
1195                         g_variant_unref(result);
1196                         g_object_unref(dev_proxy);
1197                 }
1198         }
1199         ret = TRUE;
1200         g_array_free(device_list, TRUE);
1201
1202         return ret;
1203 }
1204
1205 #if 0
1206 static gboolean __bt_set_disabled_timeout_cb(gpointer user_data)
1207 {
1208         BT_DBG("");
1209         _bt_set_disabled(BLUETOOTH_ERROR_NONE);
1210
1211         return FALSE;
1212 }
1213 #endif
1214
1215 int _bt_disable_cb(void)
1216 {
1217         FN_START;
1218         GDBusProxy *proxy;
1219 #if 0
1220         int ret;
1221 #endif
1222         GVariant *result;
1223         GError *error = NULL;
1224
1225         _bt_adapter_set_status(BT_DEACTIVATING);
1226 #if 0
1227         bt_le_status_t le_status;
1228         le_status = _bt_adapter_get_le_status();
1229         BT_DBG("le_status : %d", le_status);
1230         if (le_status == BT_LE_ACTIVATED) {
1231                 BT_INFO("LE is enabled. Just turn off PSCAN");
1232
1233                 if (_bt_is_discovering())
1234                         _bt_cancel_discovery();
1235
1236                 if (_bt_is_connectable() == FALSE) {
1237                         g_timeout_add(100, (GSourceFunc)__bt_set_disabled_timeout_cb, NULL);
1238                 } else {
1239                         ret = _bt_set_connectable(FALSE);
1240                         if (ret != BLUETOOTH_ERROR_NONE) {
1241                                 BT_ERR("_bt_set_connectable fail!");
1242                                 _bt_adapter_set_status(BT_ACTIVATED);
1243                                 return BLUETOOTH_ERROR_INTERNAL;
1244                         }
1245                 }
1246         }
1247 #endif
1248         proxy = __bt_get_core_proxy();
1249         retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
1250
1251         result = g_dbus_proxy_call_sync(proxy,
1252                                 "DisableAdapter",
1253                                 NULL,
1254                                 G_DBUS_CALL_FLAGS_NONE,
1255                                 -1,
1256                                 NULL,
1257                                 &error);
1258
1259         if (!result) {
1260                 if (error != NULL) {
1261                         BT_ERR("Failed to DisableAdapter (Error: %s)", error->message);
1262                         g_clear_error(&error);
1263                 } else
1264                         BT_ERR("Failed to DisableAdapter");
1265                 _bt_adapter_set_status(BT_ACTIVATED);
1266                 return BLUETOOTH_ERROR_INTERNAL;
1267         }
1268
1269         g_variant_unref(result);
1270         return BLUETOOTH_ERROR_NONE;
1271 }
1272
1273 int _bt_disable_adapter(void)
1274 {
1275         BT_DBG("+");
1276         int ret;
1277
1278         if (_bt_adapter_get_status() == BT_DEACTIVATING) {
1279                 BT_DBG("Disabling in progress");
1280                 return BLUETOOTH_ERROR_IN_PROGRESS;
1281         }
1282
1283         if (_bt_adapter_get_status() == BT_DEACTIVATED) {
1284                 BT_DBG("Already disabled");
1285                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1286         }
1287
1288         if (timer_id > 0) {
1289                 g_source_remove(timer_id);
1290                 timer_id = 0;
1291         }
1292
1293         __bt_disconnect_all();
1294         ret = _bt_disable_cb();
1295
1296         BT_DBG("-");
1297         return ret;
1298 }
1299
1300 int _bt_recover_adapter(void)
1301 {
1302         BT_DBG("+");
1303         GDBusProxy *proxy;
1304         GVariant *result;
1305         GError *error = NULL;
1306
1307         if (_bt_adapter_get_status() == BT_DEACTIVATING) {
1308                 BT_DBG("Disabling in progress");
1309                 return BLUETOOTH_ERROR_IN_PROGRESS;
1310         }
1311
1312         if (_bt_adapter_get_status() == BT_DEACTIVATED) {
1313                 BT_DBG("Already disabled");
1314                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1315         }
1316
1317         _bt_adapter_set_status(BT_DEACTIVATING);
1318
1319         proxy = __bt_get_core_proxy();
1320         retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
1321
1322         result = g_dbus_proxy_call_sync(proxy,
1323                                 "RecoverAdapter",
1324                                 NULL,
1325                                 G_DBUS_CALL_FLAGS_NONE,
1326                                 -1,
1327                                 NULL,
1328                                 &error);
1329
1330         if (!result) {
1331                 if (error != NULL) {
1332                         BT_ERR("Failed to RecoverAdapter (Error: %s)", error->message);
1333                         g_clear_error(&error);
1334                 } else
1335                         BT_ERR("Failed to RecoverAdapter");
1336                 return BLUETOOTH_ERROR_INTERNAL;
1337         }
1338
1339         is_recovery_mode = TRUE;
1340
1341         g_variant_unref(result);
1342         __bt_disconnect_all();
1343
1344         BT_DBG("-");
1345         return BLUETOOTH_ERROR_NONE;
1346 }
1347
1348 int _bt_reset_adapter(void)
1349 {
1350         GDBusProxy *proxy;
1351         GVariant *result;
1352         GError *error = NULL;
1353
1354         BT_DBG("");
1355
1356         proxy = __bt_get_core_proxy();
1357         if (!proxy)
1358                 return BLUETOOTH_ERROR_INTERNAL;
1359
1360         result = g_dbus_proxy_call_sync(proxy,
1361                                 "ResetAdapter",
1362                                 NULL,
1363                                 G_DBUS_CALL_FLAGS_NONE,
1364                                 -1,
1365                                 NULL,
1366                                 &error);
1367
1368         if (!result) {
1369                 if (error != NULL) {
1370                         BT_ERR("Failed to ResetAdapter (Error: %s)", error->message);
1371                         g_clear_error(&error);
1372                 } else
1373                         BT_ERR("Failed to ResetAdapter");
1374                 return BLUETOOTH_ERROR_INTERNAL;
1375         }
1376
1377         g_variant_unref(result);
1378         /* Terminate myself */
1379         if (_bt_adapter_get_status() == BT_DEACTIVATED) {
1380                 g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
1381         }
1382
1383         return BLUETOOTH_ERROR_NONE;
1384 }
1385
1386 #ifndef TIZEN_TV
1387 int _bt_check_adapter(int *status)
1388 {
1389
1390         char *adapter_path = NULL;
1391
1392         BT_CHECK_PARAMETER(status, return);
1393
1394         *status = BT_ADAPTER_DISABLED;
1395
1396         adapter_path = _bt_get_adapter_path();
1397
1398
1399         if (adapter_path != NULL)
1400                 *status = BT_ADAPTER_ENABLED;
1401
1402         g_free(adapter_path);
1403         return BLUETOOTH_ERROR_NONE;
1404 }
1405 #else
1406 int _bt_check_adapter(int *status)
1407 {
1408         GDBusProxy *proxy;
1409         GError *error = NULL;
1410         GVariant *result;
1411         GVariant *temp;
1412         gboolean powered = FALSE;
1413
1414         BT_CHECK_PARAMETER(status, return);
1415
1416         *status = BT_ADAPTER_DISABLED;
1417
1418         proxy = _bt_get_adapter_properties_proxy();
1419         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1420
1421         result = g_dbus_proxy_call_sync(proxy,
1422                                 "Get",
1423                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1424                                         "Powered"),
1425                                 G_DBUS_CALL_FLAGS_NONE,
1426                                 -1,
1427                                 NULL,
1428                                 &error);
1429
1430         if (!result) {
1431                 BT_ERR("Failed to get local address");
1432                 if (error != NULL) {
1433                         BT_ERR("Failed to get local address (Error: %s)", error->message);
1434                         g_clear_error(&error);
1435                 }
1436                 return BLUETOOTH_ERROR_INTERNAL;
1437         }
1438
1439         g_variant_get(result, "(v)", &temp);
1440         powered = g_variant_get_boolean(temp);
1441         BT_DBG("powered: %d", powered);
1442
1443         if (powered)
1444                 *status = BT_ADAPTER_ENABLED;
1445
1446         g_variant_unref(result);
1447         g_variant_unref(temp);
1448         return BLUETOOTH_ERROR_NONE;
1449 }
1450 #endif
1451
1452 int _bt_enable_adapter_le(void)
1453 {
1454         BT_DBG("+");
1455         GDBusProxy *proxy;
1456         GError *error = NULL;
1457         bt_status_t status = _bt_adapter_get_status();
1458         bt_le_status_t le_status = _bt_adapter_get_le_status();
1459         GVariant *result;
1460
1461         if (le_status == BT_LE_ACTIVATING) {
1462                 BT_ERR("Enabling in progress");
1463                 return BLUETOOTH_ERROR_IN_PROGRESS;
1464         }
1465
1466         if (le_status == BT_LE_ACTIVATED) {
1467                 BT_ERR("Already enabled");
1468                 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1469         }
1470
1471         if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
1472                 BT_ERR("Disabling in progress");
1473                 return BLUETOOTH_ERROR_DEVICE_BUSY;
1474         }
1475
1476         _bt_adapter_set_le_status(BT_LE_ACTIVATING);
1477
1478         proxy = __bt_get_core_proxy();
1479         retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
1480
1481         result = g_dbus_proxy_call_sync(proxy, "EnableAdapterLe",
1482                                         NULL,
1483                                         G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
1484                                         NULL, &error);
1485         if (error) {
1486                 BT_ERR("EnableAdapterLe failed: %s", error->message);
1487                 _bt_adapter_set_le_status(BT_DEACTIVATED);
1488                 g_clear_error(&error);
1489
1490                 /* Clean up the process */
1491                 result = g_dbus_proxy_call_sync(proxy,
1492                                         "DisableAdapterLe",
1493                                         NULL,
1494                                         G_DBUS_CALL_FLAGS_NONE,
1495                                         -1,
1496                                         NULL,
1497                                         &error);
1498
1499                 if (!result) {
1500                                 BT_ERR("Bt core call failed");
1501                                 if (error) {
1502                                         BT_ERR("EnableAdapterLE Failed %s", error->message);
1503                                         g_clear_error(&error);
1504                                 }
1505                 }
1506                 g_variant_unref(result);
1507                 /* Terminate myself */
1508                 if (_bt_adapter_get_status() == BT_DEACTIVATED)
1509                         g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
1510                 return BLUETOOTH_ERROR_INTERNAL;
1511         }
1512
1513         if (result)
1514                 g_variant_unref(result);
1515
1516         _bt_adapter_start_le_enable_timer();
1517
1518         if (status == BT_ACTIVATED) {
1519                 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
1520                 __bt_set_le_enabled();
1521         }
1522         BT_DBG("le status : %d", _bt_adapter_get_le_status());
1523         BT_DBG("-");
1524         return BLUETOOTH_ERROR_NONE;
1525 }
1526
1527 int _bt_disable_adapter_le(void)
1528 {
1529         BT_DBG("+");
1530         GDBusProxy *proxy;
1531         bt_le_status_t bt_le_state;
1532         GVariant *result;
1533         GError *error = NULL;
1534
1535         bt_le_state = _bt_adapter_get_le_status();
1536         if (bt_le_state == BT_LE_DEACTIVATING) {
1537                 BT_DBG("Disabling in progress");
1538                 return BLUETOOTH_ERROR_IN_PROGRESS;
1539         }
1540
1541         if (bt_le_state == BT_LE_DEACTIVATED) {
1542                 BT_DBG("Already disabled");
1543                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1544         }
1545
1546         _bt_adapter_set_le_status(BT_LE_DEACTIVATING);
1547
1548         proxy = __bt_get_core_proxy();
1549         if (!proxy)
1550                 return BLUETOOTH_ERROR_INTERNAL;
1551
1552         result = g_dbus_proxy_call_sync(proxy,
1553                                 "DisableAdapterLe",
1554                                 NULL,
1555                                 G_DBUS_CALL_FLAGS_NONE,
1556                                 -1,
1557                                 NULL,
1558                                 &error);
1559
1560         if (!result) {
1561                 if (error != NULL) {
1562                         BT_ERR("Bt core call failed (Error: %s)", error->message);
1563                         g_clear_error(&error);
1564                 } else
1565                         BT_ERR("Bt core call failed");
1566                 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
1567                 return BLUETOOTH_ERROR_INTERNAL;
1568         }
1569
1570         g_variant_unref(result);
1571         _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
1572         BT_DBG("le status : %d", _bt_adapter_get_le_status());
1573         BT_DBG("-");
1574         return BLUETOOTH_ERROR_NONE;
1575 }
1576
1577 int _bt_get_local_address(bluetooth_device_address_t *local_address)
1578 {
1579
1580         GDBusProxy *proxy;
1581         GError *error = NULL;
1582         const char *address;
1583         GVariant *result;
1584         GVariant *temp;
1585
1586         BT_CHECK_PARAMETER(local_address, return);
1587
1588         proxy = _bt_get_adapter_properties_proxy();
1589         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1590
1591         result = g_dbus_proxy_call_sync(proxy,
1592                                 "Get",
1593                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1594                                         "Address"),
1595                                 G_DBUS_CALL_FLAGS_NONE,
1596                                 -1,
1597                                 NULL,
1598                                 &error);
1599
1600         if (!result) {
1601                 BT_ERR("Failed to get local address");
1602                 if (error != NULL) {
1603                         BT_ERR("Failed to get local address (Error: %s)", error->message);
1604                         g_clear_error(&error);
1605                 }
1606                 return BLUETOOTH_ERROR_INTERNAL;
1607         }
1608
1609         g_variant_get(result, "(v)", &temp);
1610         address = g_variant_get_string(temp, NULL);
1611         BT_DBG("Address:%s", address);
1612
1613         if (address) {
1614                 _bt_convert_addr_string_to_type(local_address->addr, address);
1615         } else {
1616                 return BLUETOOTH_ERROR_INTERNAL;
1617         }
1618
1619         g_variant_unref(result);
1620         g_variant_unref(temp);
1621         return BLUETOOTH_ERROR_NONE;
1622 }
1623
1624 int _bt_get_local_version(bluetooth_version_t *local_version)
1625 {
1626         GDBusProxy *proxy;
1627         const char *ver = NULL;
1628         char *ptr = NULL;
1629         int ret = BLUETOOTH_ERROR_NONE;
1630         GVariant *result;
1631         GVariant *temp;
1632
1633         BT_CHECK_PARAMETER(local_version, return);
1634
1635         GError *error = NULL;
1636
1637         proxy = _bt_get_adapter_properties_proxy();
1638         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1639
1640         result = g_dbus_proxy_call_sync(proxy,
1641                                 "Get",
1642                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1643                                         "Version"),
1644                                 G_DBUS_CALL_FLAGS_NONE,
1645                                 -1,
1646                                 NULL,
1647                                 &error);
1648
1649         if (!result) {
1650                 if (error != NULL) {
1651                         BT_ERR("Failed to get local version (Error: %s)", error->message);
1652                         g_clear_error(&error);
1653                 } else
1654                         BT_ERR("Failed to get local version");
1655                 return BLUETOOTH_ERROR_INTERNAL;
1656         }
1657
1658         g_variant_get(result, "(v)", &temp);
1659         ver = g_variant_get_string(temp, NULL);
1660         BT_DBG("VERSION: %s", ver);
1661
1662         if (ver && (strlen(ver) > 0)) {
1663                 /* Check the utf8 valitation & Fill the NULL in the invalid location*/
1664                 if (!g_utf8_validate(ver, -1, (const char **)&ptr))
1665                         *ptr = '\0';
1666
1667                 g_strlcpy(local_version->version, ver,
1668                                 BLUETOOTH_VERSION_LENGTH_MAX + 1);
1669
1670         } else {
1671                 ret = BLUETOOTH_ERROR_INTERNAL;
1672         }
1673
1674         g_variant_unref(result);
1675         g_variant_unref(temp);
1676         return ret;
1677 }
1678
1679 int _bt_get_local_name(bluetooth_device_name_t *local_name)
1680 {
1681         GDBusProxy *proxy;
1682         const char *name = NULL;
1683         char *ptr = NULL;
1684         int ret = BLUETOOTH_ERROR_NONE;
1685         GVariant *result;
1686         GVariant *temp;
1687         GError *error = NULL;
1688
1689         BT_CHECK_PARAMETER(local_name, return);
1690
1691         proxy = _bt_get_adapter_properties_proxy();
1692         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1693
1694         result = g_dbus_proxy_call_sync(proxy,
1695                                 "Get",
1696                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1697                                         "Alias"),
1698                                 G_DBUS_CALL_FLAGS_NONE,
1699                                 -1,
1700                                 NULL,
1701                                 &error);
1702
1703         if (!result) {
1704                 if (error != NULL) {
1705                         BT_ERR("Failed to get local name (Error: %s)", error->message);
1706                         g_clear_error(&error);
1707                 } else
1708                         BT_ERR("Failed to get local name");
1709                 return BLUETOOTH_ERROR_INTERNAL;
1710         }
1711
1712         g_variant_get(result, "(v)", &temp);
1713         name = g_variant_get_string(temp, NULL);
1714         BT_DBG("LOCAL NAME:%s", name);
1715
1716         if (name && (strlen(name) > 0)) {
1717                 /* Check the utf8 valitation & Fill the NULL in the invalid location*/
1718                 if (!g_utf8_validate(name, -1, (const char **)&ptr))
1719                         *ptr = '\0';
1720
1721                 g_strlcpy(local_name->name, name,
1722                                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
1723         } else {
1724                 ret = BLUETOOTH_ERROR_INTERNAL;
1725         }
1726         g_variant_unref(result);
1727         g_variant_unref(temp);
1728         return ret;
1729 }
1730
1731 int _bt_set_local_name(char *local_name)
1732 {
1733         GDBusProxy *proxy;
1734         GError *error = NULL;
1735         char *ptr = NULL;
1736         GVariant *result;
1737
1738         BT_CHECK_PARAMETER(local_name, return);
1739
1740         proxy = _bt_get_adapter_properties_proxy();
1741
1742         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1743
1744         if (!g_utf8_validate(local_name, -1, (const char **)&ptr))
1745                 *ptr = '\0';
1746
1747         result = g_dbus_proxy_call_sync(proxy,
1748                                 "Set",
1749                                 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
1750                                         "Alias", g_variant_new("s", local_name)),
1751                                 G_DBUS_CALL_FLAGS_NONE,
1752                                 -1,
1753                                 NULL,
1754                                 &error);
1755
1756         if (!result) {
1757                 if (error != NULL) {
1758                         BT_ERR("Failed to set Alias (Error: %s)", error->message);
1759                         g_clear_error(&error);
1760                 } else
1761                         BT_ERR("Failed to set Alias");
1762                 return BLUETOOTH_ERROR_INTERNAL;
1763         }
1764
1765         g_variant_unref(result);
1766         return BLUETOOTH_ERROR_NONE;
1767 }
1768
1769 int _bt_is_service_used(char *service_uuid, gboolean *used)
1770 {
1771         GDBusProxy *proxy;
1772         GError *error = NULL;
1773         int ret = BLUETOOTH_ERROR_NONE;
1774         GVariant *result;
1775         GVariant *temp = NULL;
1776         GVariantIter *iter = NULL;
1777         gchar *uuid = NULL;
1778
1779         BT_DBG("+");
1780         BT_CHECK_PARAMETER(service_uuid, return);
1781         BT_CHECK_PARAMETER(used, return);
1782
1783         proxy = _bt_get_adapter_properties_proxy();
1784         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1785
1786         result = g_dbus_proxy_call_sync(proxy,
1787                                 "Get",
1788                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1789                                         "UUIDs"),
1790                                 G_DBUS_CALL_FLAGS_NONE,
1791                                 -1,
1792                                 NULL,
1793                                 &error);
1794
1795         if (!result) {
1796                 if (error != NULL) {
1797                         BT_ERR("Failed to get UUIDs (Error: %s)", error->message);
1798                         g_clear_error(&error);
1799                 } else
1800                         BT_ERR("Failed to get UUIDs");
1801                 return BLUETOOTH_ERROR_INTERNAL;
1802         }
1803
1804         g_variant_get(result, "(v)", &temp);
1805         g_variant_get(temp, "as", &iter);
1806
1807         *used = FALSE;
1808         while (g_variant_iter_loop(iter, "&s", &uuid)) {
1809                 if (strcasecmp(uuid, service_uuid) == 0) {
1810                         *used = TRUE;
1811                         break;
1812                 }
1813         }
1814         g_variant_iter_free(iter);
1815         g_variant_unref(result);
1816
1817         BT_DBG("Service Used? %d", *used);
1818
1819         return ret;
1820 }
1821
1822 static gboolean __bt_get_discoverable_property(void)
1823 {
1824         GDBusProxy *proxy;
1825         gboolean discoverable_v;
1826         GError *error = NULL;
1827         GVariant *result;
1828         GVariant *temp;
1829
1830         proxy = _bt_get_adapter_properties_proxy();
1831         retv_if(proxy == NULL, FALSE);
1832
1833         result = g_dbus_proxy_call_sync(proxy,
1834                                 "Get",
1835                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1836                                         "Discoverable"),
1837                                 G_DBUS_CALL_FLAGS_NONE,
1838                                 -1,
1839                                 NULL,
1840                                 &error);
1841
1842         if (!result) {
1843                 if (error != NULL) {
1844                         BT_ERR("Failed to get Discoverable property (Error: %s)", error->message);
1845                         g_clear_error(&error);
1846                 } else
1847                         BT_ERR("Failed to get Discoverable property");
1848                 return BLUETOOTH_ERROR_INTERNAL;
1849         }
1850
1851         g_variant_get(result, "(v)", &temp);
1852         discoverable_v = g_variant_get_boolean(temp);
1853         BT_DBG("discoverable_v:%d", discoverable_v);
1854
1855         g_variant_unref(result);
1856         g_variant_unref(temp);
1857
1858         return discoverable_v;
1859 }
1860
1861 int _bt_get_discoverable_mode(int *mode)
1862 {
1863         gboolean discoverable;
1864         unsigned int timeout;
1865
1866         BT_CHECK_PARAMETER(mode, return);
1867
1868         discoverable = __bt_get_discoverable_property();
1869         timeout = _bt_get_discoverable_timeout_property();
1870
1871         if (discoverable == TRUE) {
1872                 if (timeout == 0)
1873                         *mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
1874                 else
1875                         *mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
1876         } else {
1877                 *mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
1878         }
1879         return BLUETOOTH_ERROR_NONE;
1880 }
1881
1882
1883 int _bt_set_discoverable_mode(int discoverable_mode, int timeout)
1884 {
1885         int ret = BLUETOOTH_ERROR_NONE;
1886         gboolean inq_scan;
1887         gboolean pg_scan;
1888         GError *error = NULL;
1889         GDBusProxy *proxy;
1890         GVariant *result;
1891
1892         proxy = _bt_get_adapter_properties_proxy();
1893
1894         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1895
1896 #ifdef TIZEN_DPM_ENABLE
1897         if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE &&
1898                 _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
1899                 _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT_HANDSFREE");
1900                 return BLUETOOTH_ERROR_ACCESS_DENIED;
1901         }
1902         if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE &&
1903                  _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
1904                 _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT");
1905                 return BLUETOOTH_ERROR_ACCESS_DENIED;
1906         }
1907 #endif
1908
1909         switch (discoverable_mode) {
1910         case BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE:
1911                 pg_scan = TRUE;
1912                 inq_scan = FALSE;
1913                 timeout = 0;
1914                 break;
1915         case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
1916                 pg_scan = TRUE;
1917                 inq_scan = TRUE;
1918                 timeout = 0;
1919                 break;
1920         case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
1921                 inq_scan = TRUE;
1922                 pg_scan = TRUE;
1923                 break;
1924         default:
1925                 return BLUETOOTH_ERROR_INVALID_PARAM;
1926         }
1927
1928         BT_INFO("Req. discoverable_mode : %d, timeout : %d",
1929                         discoverable_mode, timeout);
1930
1931         result = g_dbus_proxy_call_sync(proxy,
1932                                 "Set",
1933                                 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
1934                                         "Connectable", g_variant_new("b", pg_scan)),
1935                                 G_DBUS_CALL_FLAGS_NONE,
1936                                 -1,
1937                                 NULL,
1938                                 &error);
1939
1940         if (!result) {
1941                 if (error != NULL) {
1942                         BT_ERR("Failed to set connectable property (Error: %s)", error->message);
1943                         g_clear_error(&error);
1944                 } else
1945                         BT_ERR("Failed to set connectable property");
1946                 return BLUETOOTH_ERROR_INTERNAL;
1947         }
1948         g_variant_unref(result);
1949         result = g_dbus_proxy_call_sync(proxy,
1950                                 "Set",
1951                                 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE, "Discoverable",
1952                                                 g_variant_new("b", inq_scan)),
1953                                 G_DBUS_CALL_FLAGS_NONE,
1954                                 -1,
1955                                 NULL,
1956                                 &error);
1957
1958         if (!result) {
1959                 if (error != NULL) {
1960                         BT_ERR("Failed to set Discoverable property (Error: %s)", error->message);
1961                         g_clear_error(&error);
1962                 } else
1963                         BT_ERR("Failed to set Discoverable property");
1964                 return BLUETOOTH_ERROR_INTERNAL;
1965         }
1966         g_variant_unref(result);
1967         result = g_dbus_proxy_call_sync(proxy,
1968                                 "Set",
1969                                 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
1970                                         "DiscoverableTimeout", g_variant_new("u", timeout)),
1971                                 G_DBUS_CALL_FLAGS_NONE,
1972                                 -1,
1973                                 NULL,
1974                                 &error);
1975
1976         if (!result) {
1977                 if (error != NULL) {
1978                         BT_ERR("Failed to set DiscoverableTimeout property (Error: %s)", error->message);
1979                         g_clear_error(&error);
1980                 } else
1981                         BT_ERR("Failed to set DiscoverableTimeout property");
1982                 return BLUETOOTH_ERROR_INTERNAL;
1983         }
1984
1985         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
1986                 timeout = -1;
1987
1988         ret = __bt_set_visible_time(timeout);
1989
1990         g_variant_unref(result);
1991
1992         return ret;
1993 }
1994
1995 int _bt_start_discovery(void)
1996 {
1997         GDBusProxy *proxy;
1998         GError *error = NULL;
1999         GVariant *result;
2000
2001         if (_bt_is_discovering() == TRUE) {
2002                 BT_ERR("BT is already in discovering");
2003                 return BLUETOOTH_ERROR_IN_PROGRESS;
2004         } else if (_bt_is_device_creating() == TRUE) {
2005                 BT_ERR("Bonding device is going on");
2006                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2007         }
2008
2009         proxy = _bt_get_adapter_proxy();
2010         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2011
2012         result = g_dbus_proxy_call_sync(proxy,
2013                                 "StartDiscovery",
2014                                 NULL,
2015                                 G_DBUS_CALL_FLAGS_NONE,
2016                                 -1,
2017                                 NULL,
2018                                 &error);
2019
2020         if (!result) {
2021                 if (error != NULL) {
2022                         BT_ERR("StartDiscovery failed (Error: %s)", error->message);
2023                         g_clear_error(&error);
2024                 } else
2025                         BT_ERR("StartDiscovery failed");
2026                 return BLUETOOTH_ERROR_INTERNAL;
2027         }
2028
2029         is_discovering = TRUE;
2030         cancel_by_user = FALSE;
2031         /* discovery status will be change in event */
2032         g_variant_unref(result);
2033         return BLUETOOTH_ERROR_NONE;
2034 }
2035
2036 int _bt_start_custom_discovery(bt_discovery_role_type_t role)
2037 {
2038         GDBusProxy *proxy;
2039         GVariant *result;
2040         GError *error = NULL;
2041         const gchar *disc_type;
2042
2043         if (_bt_is_discovering() == TRUE) {
2044                 BT_ERR("BT is already in discovering");
2045                 return BLUETOOTH_ERROR_IN_PROGRESS;
2046         }
2047
2048         proxy = _bt_get_adapter_proxy();
2049         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2050
2051         if (role == DISCOVERY_ROLE_BREDR)
2052                 disc_type = "BREDR";
2053         else if (role == DISCOVERY_ROLE_LE)
2054                 disc_type = "LE";
2055         else if (role == DISCOVERY_ROLE_LE_BREDR)
2056                 disc_type = "LE_BREDR";
2057         else
2058                 return BLUETOOTH_ERROR_INVALID_PARAM;
2059
2060         result = g_dbus_proxy_call_sync(proxy,
2061                                 "StartCustomDiscovery",
2062                                 g_variant_new("s", disc_type),
2063                                 G_DBUS_CALL_FLAGS_NONE,
2064                                 -1,
2065                                 NULL,
2066                                 &error);
2067
2068         if (!result) {
2069                 if (error != NULL) {
2070                         BT_ERR("StartCustomDiscovery failed (Error: %s)", error->message);
2071                         g_clear_error(&error);
2072                 } else
2073                         BT_ERR("StartCustomDiscovery failed");
2074                 return BLUETOOTH_ERROR_INTERNAL;
2075         }
2076
2077         is_discovering = TRUE;
2078         cancel_by_user = FALSE;
2079         /* discovery status will be change in event */
2080         g_variant_unref(result);
2081         return BLUETOOTH_ERROR_NONE;
2082 }
2083
2084 int _bt_cancel_discovery(void)
2085 {
2086         GDBusProxy *proxy;
2087         GError *error = NULL;
2088         GVariant *result;
2089
2090         if (_bt_is_discovering() == FALSE) {
2091                 BT_ERR("BT is not in discovering");
2092                 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
2093         }
2094
2095         proxy = _bt_get_adapter_proxy();
2096         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2097
2098         result = g_dbus_proxy_call_sync(proxy,
2099                                 "StopDiscovery",
2100                                 NULL,
2101                                 G_DBUS_CALL_FLAGS_NONE,
2102                                 -1,
2103                                 NULL,
2104                                 &error);
2105
2106         if (!result) {
2107                 int ret = BLUETOOTH_ERROR_INTERNAL;
2108                 if (error != NULL) {
2109                         BT_ERR("StopDiscovery failed (Error: %s)", error->message);
2110
2111                         if (g_strrstr(error->message, "No discovery started"))
2112                                 ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
2113
2114                         g_clear_error(&error);
2115                 } else {
2116                         BT_ERR("StopDiscovery failed");
2117                 }
2118
2119                 return ret;
2120         }
2121
2122         cancel_by_user = TRUE;
2123         /* discovery status will be change in event */
2124         g_variant_unref(result);
2125         return BLUETOOTH_ERROR_NONE;
2126 }
2127
2128 gboolean _bt_is_discovering(void)
2129 {
2130         return is_discovering;
2131 }
2132
2133 gboolean _bt_is_connectable(void)
2134 {
2135         GDBusProxy *proxy;
2136         GError *error = NULL;
2137         gboolean is_connectable = FALSE;
2138         GVariant *result;
2139         GVariant *temp;
2140
2141         proxy = _bt_get_adapter_properties_proxy();
2142         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2143
2144         result = g_dbus_proxy_call_sync(proxy,
2145                                 "Get",
2146                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
2147                                         "Connectable"),
2148                                 G_DBUS_CALL_FLAGS_NONE,
2149                                 -1,
2150                                 NULL,
2151                                 &error);
2152
2153         if (!result) {
2154                 if (error != NULL) {
2155                         BT_ERR("Failed to get connectable property (Error: %s)", error->message);
2156                         g_clear_error(&error);
2157                 } else
2158                         BT_ERR("Failed to get connectable property");
2159                 return BLUETOOTH_ERROR_INTERNAL;
2160         }
2161
2162         g_variant_get(result, "(v)", &temp);
2163         is_connectable = g_variant_get_boolean(temp);
2164         BT_DBG("discoverable_v:%d", is_connectable);
2165
2166         g_variant_unref(result);
2167         g_variant_unref(temp);
2168
2169         BT_INFO("Get connectable [%d]", is_connectable);
2170         return is_connectable;
2171 }
2172
2173 int _bt_set_connectable(gboolean is_connectable)
2174 {
2175         GDBusProxy *proxy;
2176         GError *error = NULL;
2177         GVariant *result;
2178
2179         if (__bt_is_factory_test_mode()) {
2180                 BT_ERR("Unable to set connectable in factory binary !!");
2181                 return BLUETOOTH_ERROR_NOT_SUPPORT;
2182         }
2183
2184         proxy = _bt_get_adapter_properties_proxy();
2185
2186         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2187
2188         result = g_dbus_proxy_call_sync(proxy,
2189                                 "Set",
2190                                 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE, "Connectable",
2191                                                 g_variant_new("b", is_connectable)),
2192                                 G_DBUS_CALL_FLAGS_NONE,
2193                                 -1,
2194                                 NULL,
2195                                 &error);
2196
2197         if (!result) {
2198                 if (error != NULL) {
2199                         BT_ERR("Failed to set connectable property (Error: %s)", error->message);
2200                         g_clear_error(&error);
2201                 } else
2202                         BT_ERR("Failed to set connectable property");
2203                 return BLUETOOTH_ERROR_INTERNAL;
2204         }
2205
2206         BT_INFO("### Set connectable [%d]", is_connectable);
2207         g_variant_unref(result);
2208         return BLUETOOTH_ERROR_NONE;
2209 }
2210
2211 gboolean _bt_get_discovering_property(bt_discovery_role_type_t discovery_type)
2212 {
2213         GDBusProxy *proxy;
2214         gboolean discovering_v;
2215         GError *error = NULL;
2216         char *discovering_type =  NULL;
2217         GVariant *result;
2218         GVariant *temp;
2219
2220         proxy = _bt_get_adapter_properties_proxy();
2221         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2222
2223         if (discovery_type == DISCOVERY_ROLE_BREDR)
2224                 discovering_type = "Discovering";
2225         else if (discovery_type == DISCOVERY_ROLE_LE)
2226                 discovering_type = "LEDiscovering";
2227
2228         result = g_dbus_proxy_call_sync(proxy,
2229                                 "Get",
2230                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
2231                                         discovering_type),
2232                                 G_DBUS_CALL_FLAGS_NONE,
2233                                 -1,
2234                                 NULL,
2235                                 &error);
2236
2237         if (!result) {
2238                 if (error != NULL) {
2239                         BT_ERR("Failed to get discovering property (Error: %s)", error->message);
2240                         g_clear_error(&error);
2241                 } else
2242                         BT_ERR("Failed to get discovering property");
2243                 return BLUETOOTH_ERROR_INTERNAL;
2244         }
2245
2246         g_variant_get(result, "(v)", &temp);
2247         discovering_v = g_variant_get_boolean(temp);
2248         BT_DBG("discoverable_v:%d", discovering_v);
2249
2250         g_variant_unref(result);
2251         g_variant_unref(temp);
2252
2253         return discovering_v;
2254 }
2255
2256 unsigned int _bt_get_discoverable_timeout_property(void)
2257 {
2258         GDBusProxy *proxy;
2259         unsigned int timeout_v;
2260         GError *error = NULL;
2261         GVariant *result;
2262         GVariant *temp;
2263
2264         proxy = _bt_get_adapter_properties_proxy();
2265         retv_if(proxy == NULL, 0);
2266
2267         result = g_dbus_proxy_call_sync(proxy,
2268                                 "Get",
2269                                 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
2270                                         "DiscoverableTimeout"),
2271                                 G_DBUS_CALL_FLAGS_NONE,
2272                                 -1,
2273                                 NULL,
2274                                 &error);
2275
2276         if (!result) {
2277                 BT_ERR("Fail to get discoverable timeout");
2278                 if (error != NULL) {
2279                         BT_ERR("Fail to get discoverable timeout (Error: %s)", error->message);
2280                         g_clear_error(&error);
2281                 }
2282                 return 0;
2283         }
2284
2285         g_variant_get(result, "(v)", &temp);
2286         timeout_v = g_variant_get_uint32(temp);
2287         BT_DBG("discoverable_v:%d", timeout_v);
2288
2289         g_variant_unref(result);
2290         g_variant_unref(temp);
2291
2292         return timeout_v;
2293 }
2294
2295 static bluetooth_device_info_t *__bt_parse_device_info(GVariantIter *item_iter)
2296 {
2297         bluetooth_device_info_t *dev_info;
2298         GVariant *value;
2299         const gchar *key;
2300         GByteArray *manufacturer_data = NULL;
2301         guint8 char_value;
2302         GVariantIter *char_value_iter;
2303
2304         dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
2305
2306         while (g_variant_iter_loop(item_iter, "{sv}", &key, &value)) {
2307
2308                 if (key == NULL)
2309                         continue;
2310
2311                 if (!g_strcmp0(key, "Address")) {
2312                         const char *address = NULL;
2313                         address = g_variant_get_string(value, NULL);
2314                         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
2315                                                         address);
2316                 } else if (!g_strcmp0(key, "Class")) {
2317                         unsigned int cod;
2318                         cod = g_variant_get_uint32(value);
2319                         _bt_divide_device_class(&dev_info->device_class, cod);
2320                 } else if (!g_strcmp0(key, "Name")) {
2321                         const char *name = NULL;
2322                         name = g_variant_get_string(value, NULL);
2323                         /* If there is no Alias */
2324                         if (strlen(dev_info->device_name.name) == 0) {
2325                                 g_strlcpy(dev_info->device_name.name, name,
2326                                                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
2327                         }
2328                 } else if (!g_strcmp0(key, "Alias")) {
2329                         const char *alias = NULL;
2330                         alias = g_variant_get_string(value, NULL);
2331                         /* Overwrite the name */
2332                         if (alias) {
2333                                 memset(dev_info->device_name.name, 0x00,
2334                                                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
2335                                 g_strlcpy(dev_info->device_name.name, alias,
2336                                                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
2337                         }
2338                 } else if (!g_strcmp0(key, "IsAliasSet")) {
2339                         dev_info->is_alias_set = g_variant_get_boolean(value);
2340                 } else if (!g_strcmp0(key, "Connected")) {
2341                         dev_info->connected = g_variant_get_byte(value);
2342                 } else if (!g_strcmp0(key, "Paired")) {
2343                         dev_info->paired = g_variant_get_boolean(value);
2344                 } else if (!g_strcmp0(key, "Trusted")) {
2345                         dev_info->trust = g_variant_get_boolean(value);
2346                 } else if (!g_strcmp0(key, "RSSI")) {
2347                         dev_info->rssi = g_variant_get_int16(value);
2348                 } else if (!g_strcmp0(key, "UUIDs")) {
2349                         GVariantIter *iter;
2350                         gchar *uuid = NULL;
2351                         char **parts;
2352                         int i = 0;
2353
2354                         dev_info->service_index = 0;
2355                         g_variant_get(value, "as", &iter);
2356                         while (g_variant_iter_loop(iter, "s", &uuid)) {
2357                                 g_strlcpy(dev_info->uuids[i], uuid, BLUETOOTH_UUID_STRING_MAX);
2358                                 parts = g_strsplit(uuid, "-", -1);
2359
2360                                 if (parts == NULL || parts[0] == NULL) {
2361                                         g_free(uuid);
2362                                         break;
2363                                 }
2364
2365                                 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
2366                                 g_strfreev(parts);
2367
2368                                 i++;
2369                         }
2370                         dev_info->service_index = i;
2371                         g_variant_iter_free(iter);
2372                 } else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
2373                         dev_info->manufacturer_data.data_len = g_variant_get_uint16(value);
2374                 } else if (strcasecmp(key, "ManufacturerData") == 0) {
2375                         manufacturer_data = g_byte_array_new();
2376                         g_variant_get(value, "ay", &char_value_iter);
2377                         while (g_variant_iter_loop(char_value_iter, "y",  &char_value)) {
2378                                 g_byte_array_append(manufacturer_data, &char_value, 1);
2379                         }
2380                         if (manufacturer_data) {
2381                                 if (manufacturer_data->len > 0) {
2382                                         memcpy(dev_info->manufacturer_data.data, manufacturer_data->data, manufacturer_data->len);
2383                                 }
2384                         }
2385                         g_variant_iter_free(char_value_iter);
2386                         g_byte_array_free(manufacturer_data, TRUE);
2387                 }
2388         }
2389
2390         return dev_info;
2391 }
2392
2393 static void __bt_extract_device_info(GVariantIter *iter,
2394                                                         GArray **dev_list)
2395 {
2396         bluetooth_device_info_t *dev_info = NULL;
2397         char *object_path = NULL;
2398         GVariantIter *interface_iter;
2399         GVariantIter *svc_iter;
2400         char *interface_str = NULL;
2401
2402         /* Parse the signature:  oa{sa{sv}}} */
2403         while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
2404                 &interface_iter)) {
2405
2406                 if (object_path == NULL)
2407                         continue;
2408
2409                 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
2410                                 &interface_str, &svc_iter)) {
2411                         if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
2412                                 BT_DBG("Found a device: %s", object_path);
2413                                 dev_info = __bt_parse_device_info(svc_iter);
2414                                 if (dev_info) {
2415                                         if (dev_info->paired == TRUE) {
2416                                                 g_array_append_vals(*dev_list, dev_info,
2417                                                                 sizeof(bluetooth_device_info_t));
2418                                         }
2419                                         g_free(dev_info);
2420                                 }
2421                                 g_free(interface_str);
2422                                 g_variant_iter_free(svc_iter);
2423                                 break;
2424                         }
2425                 }
2426         }
2427         BT_DBG("-");
2428 }
2429
2430 int _bt_get_bonded_devices(GArray **dev_list)
2431 {
2432         BT_DBG("+");
2433         GDBusConnection *conn;
2434         GDBusProxy *manager_proxy;
2435         GVariant *result = NULL;
2436         GVariantIter *iter = NULL;
2437         GError *error = NULL;
2438
2439         conn = _bt_get_system_conn();
2440         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2441
2442         manager_proxy = _bt_get_manager_proxy();
2443         retv_if(manager_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2444
2445         result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
2446                                 NULL,
2447                                 G_DBUS_CALL_FLAGS_NONE,
2448                                 -1,
2449                                 NULL,
2450                                 NULL);
2451
2452         if (!result) {
2453                 if (error != NULL) {
2454                         BT_ERR("Failed to GetManagedObjects (Error: %s)", error->message);
2455                         g_clear_error(&error);
2456                 } else
2457                         BT_ERR("Failed to Failed to GetManagedObjects");
2458                 return BLUETOOTH_ERROR_INTERNAL;
2459         }
2460
2461         /* signature of GetManagedObjects:  a{oa{sa{sv}}} */
2462         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
2463
2464         __bt_extract_device_info(iter, dev_list);
2465         g_variant_iter_free(iter);
2466         g_variant_unref(result);
2467
2468         BT_DBG("-");
2469         return BLUETOOTH_ERROR_NONE;
2470 }
2471
2472 int _bt_get_profile_connected_devices(char *profile_uuid, GArray **addr_list)
2473 {
2474         BT_DBG("+");
2475         GDBusConnection *conn;
2476         GDBusProxy *manager_proxy;
2477         GVariant *result = NULL;
2478         GVariant *result1 = NULL;
2479         GVariantIter *iter = NULL;
2480         GError *error = NULL;
2481         char *object_path = NULL;
2482         GVariantIter *interface_iter;
2483         char *interface_str = NULL;
2484         GDBusProxy *device_proxy = NULL;
2485         gboolean is_connected = FALSE;
2486
2487         conn = _bt_get_system_conn();
2488         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2489
2490         manager_proxy = _bt_get_manager_proxy();
2491         retv_if(manager_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2492
2493         result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
2494                                 NULL,
2495                                 G_DBUS_CALL_FLAGS_NONE,
2496                                 -1,
2497                                 NULL,
2498                                 NULL);
2499
2500         if (!result) {
2501                 if (error != NULL) {
2502                         BT_ERR("Failed to GetManagedObjects (Error: %s)", error->message);
2503                         g_clear_error(&error);
2504                         error = NULL;
2505                 } else
2506                         BT_ERR("Failed to Failed to GetManagedObjects");
2507                 return BLUETOOTH_ERROR_INTERNAL;
2508         }
2509
2510         /* signature of GetManagedObjects:  a{oa{sa{sv}}} */
2511         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
2512
2513         /* Parse the signature:  oa{sa{sv}}} */
2514         while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
2515                 if (object_path == NULL)
2516                         continue;
2517
2518                 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
2519                                 &interface_str, NULL)) {
2520                         if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
2521                                 BT_DBG("Found a device: %s", object_path);
2522                                 g_free(interface_str);
2523
2524                                 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
2525                                                                                         NULL, BT_BLUEZ_NAME,
2526                                                                                         object_path, BT_DEVICE_INTERFACE,  NULL, NULL);
2527
2528                                 if (device_proxy == NULL) {
2529                                         BT_DBG("Device don't have this service");
2530                                         break;
2531                                 }
2532
2533                                 result1 = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
2534                                                         g_variant_new("(s)", profile_uuid),
2535                                                         G_DBUS_CALL_FLAGS_NONE,
2536                                                         -1,
2537                                                         NULL,
2538                                                         &error);
2539
2540                                 if (result1 == NULL) {
2541                                         BT_ERR("Error occured in Proxy call");
2542                                         if (error) {
2543                                                 BT_ERR("Error occured in Proxy call [%s]\n", error->message);
2544                                                 g_error_free(error);
2545                                                 error = NULL;
2546                                         }
2547                                         g_object_unref(device_proxy);
2548                                         break;
2549                                 }
2550                                 g_variant_get(result1, "(b)", &is_connected);
2551
2552                                 if (is_connected == TRUE) {
2553                                         char address[BT_ADDRESS_STRING_SIZE];
2554                                         bluetooth_device_address_t *addr = NULL;
2555
2556                                         _bt_convert_device_path_to_address(object_path, address);
2557
2558                                         addr = g_malloc0(sizeof(bluetooth_device_address_t));
2559                                         _bt_convert_addr_string_to_type(addr->addr, address);
2560
2561                                         g_array_append_vals(*addr_list, addr,
2562                                                         sizeof(bluetooth_device_address_t));
2563                                 }
2564
2565                                 g_variant_unref(result1);
2566                                 g_object_unref(device_proxy);
2567
2568                                 break;
2569                         }
2570                 }
2571         }
2572
2573         g_variant_unref(result);
2574         g_variant_iter_free(iter);
2575
2576         BT_DBG("-");
2577         return BLUETOOTH_ERROR_NONE;
2578 }
2579
2580 int _bt_get_bonded_device_info(bluetooth_device_address_t *device_address,
2581                                 bluetooth_device_info_t *dev_info)
2582 {
2583         char *object_path = NULL;
2584         GDBusProxy *adapter_proxy;
2585         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2586         int ret = BLUETOOTH_ERROR_NONE;
2587
2588         BT_CHECK_PARAMETER(device_address, return);
2589         BT_CHECK_PARAMETER(dev_info, return);
2590
2591         adapter_proxy = _bt_get_adapter_proxy();
2592         retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2593
2594         _bt_convert_addr_type_to_string(address, device_address->addr);
2595
2596         object_path = _bt_get_device_object_path(address);
2597
2598         retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
2599
2600         ret = __bt_get_bonded_device_info(object_path, dev_info);
2601         g_free(object_path);
2602
2603         return ret;
2604 }
2605
2606 int _bt_get_timeout_value(int *timeout)
2607 {
2608         time_t current_time;
2609         int time_diff;
2610
2611         /* Take current time */
2612         time(&current_time);
2613         time_diff = difftime(current_time, visible_timer.start_time);
2614
2615         BT_DBG("Time diff = %d\n", time_diff);
2616
2617         *timeout = visible_timer.timeout - time_diff;
2618
2619         return BLUETOOTH_ERROR_NONE;
2620 }
2621
2622 int _bt_set_le_privacy(gboolean set_privacy)
2623 {
2624         GDBusProxy *proxy;
2625         GError *error = NULL;
2626         GVariant *result = NULL;
2627
2628         if (__bt_is_factory_test_mode()) {
2629                 BT_ERR("Unable to set le privacy in factory binary !!");
2630                 return BLUETOOTH_ERROR_NOT_SUPPORT;
2631         }
2632
2633         if (_bt_adapter_get_status() != BT_ACTIVATED &&
2634                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2635                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2636         }
2637
2638         proxy = _bt_get_adapter_proxy();
2639         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2640
2641         result = g_dbus_proxy_call_sync(proxy,
2642                                 "SetLePrivacy",
2643                                 g_variant_new("(b)", set_privacy),
2644                                 G_DBUS_CALL_FLAGS_NONE,
2645                                 -1,
2646                                 NULL,
2647                                 &error);
2648
2649         if (!result) {
2650                 if (error != NULL) {
2651                         BT_ERR("Failed to SetLePrivacy (Error: %s)", error->message);
2652                         g_clear_error(&error);
2653                 } else
2654                         BT_ERR("Failed to SetLePrivacy");
2655                 return BLUETOOTH_ERROR_INTERNAL;
2656         }
2657
2658         g_variant_unref(result);
2659         BT_INFO("SetLePrivacy as %d", set_privacy);
2660         return BLUETOOTH_ERROR_NONE;
2661 }
2662
2663 int _bt_set_le_static_random_address(gboolean is_enable)
2664 {
2665         GDBusProxy *proxy;
2666         GError *error = NULL;
2667         GVariant *result = NULL;
2668
2669         if (__bt_is_factory_test_mode()) {
2670                 BT_ERR("Unable to set le random address in factory binary !!");
2671                 return BLUETOOTH_ERROR_NOT_SUPPORT;
2672         }
2673
2674         if (_bt_adapter_get_status() != BT_ACTIVATED &&
2675                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2676                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2677         }
2678
2679         proxy = _bt_get_adapter_proxy();
2680         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2681
2682         result = g_dbus_proxy_call_sync(proxy,
2683                                 "SetLeStaticRandomAddress",
2684                                 g_variant_new("(b)", is_enable),
2685                                 G_DBUS_CALL_FLAGS_NONE,
2686                                 -1,
2687                                 NULL,
2688                                 &error);
2689
2690         if (!result) {
2691                 if (error != NULL) {
2692                         BT_ERR("Failed to SetLeStaticRandomAddress (Error: %s)", error->message);
2693                         g_clear_error(&error);
2694                 } else
2695                         BT_ERR("Failed to SetLeStaticRandomAddress");
2696                 return BLUETOOTH_ERROR_INTERNAL;
2697         }
2698
2699         g_variant_unref(result);
2700         BT_INFO("SetLeStaticRandomAddress as %d", is_enable);
2701         return BLUETOOTH_ERROR_NONE;
2702 }
2703
2704 int _bt_set_manufacturer_data(bluetooth_manufacturer_data_t *m_data)
2705 {
2706         GDBusProxy *proxy;
2707         GError *error = NULL;
2708         int i;
2709         GVariant *val;
2710         GVariant *result;
2711         GVariantBuilder *builder;
2712
2713         BT_CHECK_PARAMETER(m_data, return);
2714
2715         if (_bt_adapter_get_status() != BT_ACTIVATED &&
2716                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2717                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2718         }
2719
2720         proxy = _bt_get_adapter_proxy();
2721         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2722
2723         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
2724
2725         for (i = 0; i < (m_data->data_len) + 2; i++) {
2726                 g_variant_builder_add(builder, "y", m_data->data[i]);
2727         }
2728
2729         val = g_variant_new("(ay)", builder);
2730
2731         result = g_dbus_proxy_call_sync(proxy,
2732                                 "SetManufacturerData",
2733                                 val,
2734                                 G_DBUS_CALL_FLAGS_NONE,
2735                                 -1,
2736                                 NULL,
2737                                 &error);
2738         g_variant_builder_unref(builder);
2739         if (!result) {
2740                 if (error != NULL) {
2741                         BT_ERR("Failed to SetManufacturerData (Error: %s)", error->message);
2742                         g_clear_error(&error);
2743                 } else {
2744                         BT_ERR("Failed to SetManufacturerData");
2745                 }
2746                 return BLUETOOTH_ERROR_INTERNAL;
2747         }
2748         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
2749
2750         for (i = 0; i < (m_data->data_len) + 2; i++) {
2751                 g_variant_builder_add(builder, "y", m_data->data[i]);
2752         }
2753
2754         val = g_variant_new("(ay)", builder);
2755
2756         _bt_send_event(BT_ADAPTER_EVENT,
2757                         BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
2758                         val);
2759
2760         BT_INFO("Set manufacturer data");
2761
2762         g_variant_builder_unref(builder);
2763         g_variant_unref(result);
2764
2765         return BLUETOOTH_ERROR_NONE;
2766 }
2767
2768
2769 int _bt_service_set_alarm(int timeout, bt_set_alarm_cb call_back, void *user_data, alarm_id_t *alarm_id)
2770 {
2771         int result = BLUETOOTH_ERROR_NONE;
2772         bt_service_alarm_t *alarm = NULL;
2773
2774         if(!call_back || !alarm_id)
2775                 return BLUETOOTH_ERROR_INVALID_PARAM;
2776
2777         if (!alarm_mgr.is_alarm_initialized) {
2778                 result = alarmmgr_init("bt-service");
2779                 if (result != 0) {
2780                         BT_ERR("Failed to initialize alarm = %d",result);
2781                         result = BLUETOOTH_ERROR_INTERNAL;
2782                         goto finish;
2783                 }
2784                 result = alarmmgr_set_cb(alarm_cb, NULL);
2785                 if (result != 0) {
2786                         BT_ERR("Failed to set the callback = %d",result);
2787                         result = BLUETOOTH_ERROR_INTERNAL;
2788                         goto finish;
2789                 }
2790                 alarm_mgr.is_alarm_initialized = TRUE;
2791         }
2792
2793         alarm = g_malloc0(sizeof(bt_service_alarm_t));
2794         if(!alarm)
2795                 return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
2796
2797         result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, timeout,
2798                                                 0, NULL, alarm_id);
2799         if (result != 0) {
2800                 BT_ERR("Failed to create alarm error = %d",result);
2801                 result = BLUETOOTH_ERROR_INTERNAL;
2802                 g_free(alarm);
2803                 goto finish;
2804         }
2805         alarm->alarm_id = *alarm_id;
2806         alarm->callback = call_back;
2807         alarm->user_data = user_data;
2808
2809         alarm_mgr.g_alarm_list = g_list_append(alarm_mgr.g_alarm_list, alarm);
2810         result = BLUETOOTH_ERROR_NONE;
2811 finish:
2812         return result;
2813 }
2814
2815 static int alarm_cb(alarm_id_t alarm_id, void* user_param)
2816 {
2817         GList *node = NULL;
2818         bt_service_alarm_t *p_data;
2819         bt_set_alarm_cb callback = NULL;
2820         void *user_data = NULL;
2821
2822         node = g_list_find_custom(alarm_mgr.g_alarm_list,
2823                         GINT_TO_POINTER(alarm_id), compare_alarm);
2824         if (!node)
2825                 return 0;
2826
2827         p_data = (bt_service_alarm_t *)node->data;
2828         alarm_mgr.g_alarm_list = g_list_delete_link(alarm_mgr.g_alarm_list,
2829                         node);
2830
2831         if (!p_data)
2832                 return 0;
2833
2834         callback = p_data->callback;
2835         user_data = p_data->user_data;
2836         g_free(p_data);
2837
2838         if (callback)
2839                 callback(alarm_id, user_data);
2840
2841         return 0;
2842 }
2843
2844 int _bt_service_remove_alarm(alarm_id_t alarm_id)
2845 {
2846         GList *list = NULL;
2847         bt_service_alarm_t *p_data;
2848         list = g_list_find_custom(alarm_mgr.g_alarm_list, GINT_TO_POINTER(alarm_id), compare_alarm);
2849
2850         if (list != NULL) {
2851                 alarmmgr_remove_alarm(alarm_id);
2852                 p_data = (bt_service_alarm_t *)list->data;
2853                 alarm_mgr.g_alarm_list = g_list_remove(alarm_mgr.g_alarm_list, list->data);
2854                 g_free(p_data);
2855         }
2856
2857         return 0;
2858 }
2859
2860 gint compare_alarm(gconstpointer list_data, gconstpointer data)
2861 {
2862         alarm_id_t alarm_id = (alarm_id_t)data;
2863         bt_service_alarm_t *p_data = (bt_service_alarm_t *)list_data;
2864
2865         if (p_data->alarm_id == alarm_id) {
2866                 return 0;
2867         }
2868         return 1;
2869 }
2870
2871 static void alarm_data_free(void *data)
2872 {
2873         bt_service_alarm_t *p_data = (bt_service_alarm_t *)data;
2874         g_free(p_data);
2875         return;
2876 }
2877
2878 static gboolean _bt_adapter_request_delayed_cb(gpointer user_data)
2879 {
2880         int result;
2881         int function = (int)user_data;
2882
2883         switch (function) {
2884         case BT_ENABLE_ADAPTER:
2885                 result = _bt_enable_adapter();
2886                 if (result != BLUETOOTH_ERROR_NONE) {
2887                         BT_ERR("_bt_enable_adapter is failed");
2888                         /* Send enabled event to API */
2889                         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
2890                                         g_variant_new("(i)", result));
2891                 }
2892                 break;
2893         case BT_DISABLE_ADAPTER:
2894                 result = _bt_disable_adapter();
2895                 if (result != BLUETOOTH_ERROR_NONE) {
2896                         BT_ERR("_bt_disable_adapter is failed");
2897                         /* Send disabled event to API */
2898                         _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
2899                                         g_variant_new("(i)", result));
2900                 }
2901                 break;
2902         default:
2903                 BT_ERR("function is NOT matched");
2904                 break;
2905         }
2906
2907         return FALSE;
2908 }
2909
2910 int _bt_adapter_request_delayed(int function)
2911 {
2912         bt_status_t status = _bt_adapter_get_status();
2913         bt_le_status_t le_status = _bt_adapter_get_le_status();
2914
2915         switch (function) {
2916         case BT_ENABLE_ADAPTER:
2917                 if (status == BT_ACTIVATING) {
2918                         BT_ERR("Enabling in progress");
2919                         return BLUETOOTH_ERROR_IN_PROGRESS;
2920                 }
2921
2922                 if (status == BT_ACTIVATED) {
2923                         BT_ERR("Already enabled");
2924                         return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
2925                 }
2926
2927                 if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
2928                         BT_ERR("Disabling in progress");
2929                         return BLUETOOTH_ERROR_DEVICE_BUSY;
2930                 }
2931
2932                 break;
2933         case BT_DISABLE_ADAPTER:
2934                 if (status == BT_DEACTIVATING) {
2935                         BT_DBG("Disabling in progress");
2936                         return BLUETOOTH_ERROR_IN_PROGRESS;
2937                 }
2938
2939                 if (status == BT_DEACTIVATED) {
2940                         BT_DBG("Already disabled");
2941                         return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2942                 }
2943
2944                 break;
2945         default:
2946                 BT_ERR("function is NOT matched");
2947                 return BLUETOOTH_ERROR_INTERNAL;
2948         }
2949
2950         g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void*)function);
2951
2952         return BLUETOOTH_ERROR_NONE;
2953 }
2954
2955 #ifdef TIZEN_TV
2956 int _bt_get_enable_timer_id(void)
2957 {
2958         return timer_id;
2959 }
2960 #endif