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