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