bt-service/bt-service-adapter.c

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