2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include <syspopup_caller.h>
26 #include <dbus/dbus-glib.h>
27 #include <dbus/dbus.h>
29 #include <eventsystem.h>
30 #include <bundle_internal.h>
33 #include "bluetooth-api.h"
34 #include "bt-internal-types.h"
35 #include "bt-service-common.h"
36 #include "bt-service-event.h"
37 #include "bt-service-adapter.h"
38 #include "bt-service-util.h"
39 #include "bt-service-network.h"
40 #include "bt-service-obex-server.h"
41 #include "bt-service-opp-client.h"
42 #include "bt-service-agent.h"
43 #include "bt-service-main.h"
44 #include "bt-service-avrcp.h"
45 #include "bt-service-device.h"
46 #ifdef TIZEN_FEATURE_BT_DPM
47 #include "bt-service-dpm.h"
57 bt_adapter_timer_t visible_timer = {0, };
61 bt_set_alarm_cb callback;
66 gboolean is_alarm_initialized;
68 } bt_service_alarm_mgr_t;
70 static bt_service_alarm_mgr_t alarm_mgr = {0, };
72 static gboolean is_discovering;
73 static gboolean cancel_by_user;
74 static bt_status_t adapter_status = BT_DEACTIVATED;
75 static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
76 static gboolean is_le_intended = FALSE;
77 static void *adapter_agent = NULL;
78 static GDBusProxy *core_proxy = NULL;
79 static guint timer_id = 0;
80 static guint le_timer_id = 0;
81 static gboolean is_recovery_mode;
83 static uint status_reg_id;
85 #define BT_CORE_NAME "org.projectx.bt_core"
86 #define BT_CORE_PATH "/org/projectx/bt_core"
87 #define BT_CORE_INTERFACE "org.projectx.btcore"
89 #define BT_DISABLE_TIME 500 /* 500 ms */
91 static int alarm_cb(alarm_id_t alarm_id, void* user_param);
92 static void alarm_data_free(void *data);
94 GDBusProxy *_bt_init_core_proxy(void)
97 GDBusConnection *conn;
99 conn = _bt_gdbus_get_system_gconn();
103 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
118 static GDBusProxy *__bt_get_core_proxy(void)
120 return (core_proxy) ? core_proxy : _bt_init_core_proxy();
123 static gboolean __bt_is_factory_test_mode(void)
127 if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
128 BT_ERR("Get the DUT Mode fail");
133 BT_INFO("DUT Test Mode !!");
140 static gboolean __bt_timeout_handler(gpointer user_data)
142 int result = BLUETOOTH_ERROR_NONE;
146 /* Take current time */
148 time_diff = difftime(current_time, visible_timer.start_time);
150 /* Send event to application */
151 _bt_send_event(BT_ADAPTER_EVENT,
152 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
153 g_variant_new("(in)", result, time_diff));
155 if (visible_timer.timeout <= time_diff) {
156 g_source_remove(visible_timer.event_id);
157 visible_timer.event_id = 0;
158 visible_timer.timeout = 0;
160 #ifndef TIZEN_PROFILE_WEARABLE
161 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
162 BT_ERR("Set vconf failed\n");
170 static int __bt_visibility_alarm_cb(alarm_id_t alarm_id, void* user_param)
173 int result = BLUETOOTH_ERROR_NONE;
176 if (alarm_id != visible_timer.alarm_id)
179 if (visible_timer.event_id) {
180 _bt_send_event(BT_ADAPTER_EVENT,
181 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
182 g_variant_new("(in)", result, timeout));
183 g_source_remove(visible_timer.event_id);
184 visible_timer.event_id = 0;
185 visible_timer.timeout = 0;
187 #ifndef TIZEN_PROFILE_WEARABLE
188 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
189 BT_ERR("Set vconf failed\n");
192 /* Switch Off visibility in Bluez */
193 _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
194 visible_timer.alarm_id = 0;
198 static void __bt_visibility_alarm_remove()
200 if (visible_timer.event_id > 0) {
201 g_source_remove(visible_timer.event_id);
202 visible_timer.event_id = 0;
205 if (visible_timer.alarm_id > 0) {
206 _bt_service_remove_alarm(visible_timer.alarm_id);
207 visible_timer.alarm_id = 0;
211 int __bt_set_visible_time(int timeout)
216 __bt_visibility_alarm_remove();
218 visible_timer.timeout = timeout;
220 #ifndef TIZEN_PROFILE_WEARABLE
221 #ifdef TIZEN_FEATURE_BT_DPM
222 if (_bt_dpm_get_bluetooth_limited_discoverable_state() != DPM_RESTRICTED) {
224 if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
225 BT_ERR("Set vconf failed");
226 #ifdef TIZEN_FEATURE_BT_DPM
233 return BLUETOOTH_ERROR_NONE;
235 result = _bt_service_set_alarm(visible_timer.timeout,
236 __bt_visibility_alarm_cb, NULL, &alarm_id);
237 if (result != BLUETOOTH_ERROR_NONE)
238 return BLUETOOTH_ERROR_INTERNAL;
239 visible_timer.alarm_id = alarm_id;
240 /* Take start time */
241 time(&(visible_timer.start_time));
242 visible_timer.event_id = g_timeout_add_seconds(1,
243 __bt_timeout_handler, NULL);
245 return BLUETOOTH_ERROR_NONE;
248 static void __bt_get_service_list(GVariant *value, bluetooth_device_info_t *dev)
255 ret_if(value == NULL);
258 dev->service_index = 0;
260 g_variant_get(value, "as", &iter);
261 while (g_variant_iter_loop(iter, "s", &uuid)) {
262 g_strlcpy(dev->uuids[i], uuid, BLUETOOTH_UUID_STRING_MAX);
263 parts = g_strsplit(uuid, "-", -1);
265 if (parts == NULL || parts[0] == NULL) {
270 dev->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
273 dev->service_index++;
276 g_variant_iter_free(iter);
279 static int __bt_get_bonded_device_info(gchar *device_path,
280 bluetooth_device_info_t *dev_info)
282 GError *error = NULL;
283 GDBusProxy *device_proxy;
284 gchar *address = NULL;
286 unsigned int cod = 0;
288 gboolean trust = FALSE;
289 gboolean paired = FALSE;
290 guchar connected = 0;
291 GByteArray *manufacturer_data = NULL;
293 GDBusConnection *conn;
295 GVariantIter *property_iter;
299 GVariantIter *char_value_iter;
301 BT_CHECK_PARAMETER(device_path, return);
302 BT_CHECK_PARAMETER(dev_info, return);
304 conn = _bt_gdbus_get_system_gconn();
305 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
307 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
311 BT_PROPERTIES_INTERFACE,
314 retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
316 result = g_dbus_proxy_call_sync(device_proxy,
318 g_variant_new("(s)", BT_DEVICE_INTERFACE),
319 G_DBUS_CALL_FLAGS_NONE,
325 BT_ERR("Error occured in Proxy call");
327 BT_ERR("Error occured in Proxy call (Error: %s)", error->message);
328 g_clear_error(&error);
330 g_object_unref(device_proxy);
331 return BLUETOOTH_ERROR_INTERNAL;
334 g_object_unref(device_proxy);
336 g_variant_get(result, "(a{sv})", &property_iter);
338 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
339 if (!g_strcmp0(key, "Paired")) {
340 paired = g_variant_get_boolean(value);
341 } else if (!g_strcmp0(key, "Address")) {
342 g_variant_get(value, "s", &address);
343 } else if (!g_strcmp0(key, "Alias")) {
344 g_variant_get(value, "s", &name);
345 } else if (!g_strcmp0(key, "Name")) {
347 g_variant_get(value, "s", &name);
348 } else if (!g_strcmp0(key, "Class")) {
349 cod = g_variant_get_uint32(value);
350 } else if (!g_strcmp0(key, "Connected")) {
351 connected = g_variant_get_byte(value);
352 } else if (!g_strcmp0(key, "Trusted")) {
353 trust = g_variant_get_boolean(value);
354 } else if (!g_strcmp0(key, "RSSI")) {
355 rssi = g_variant_get_int16(value);
356 } else if (!g_strcmp0(key, "UUIDs")) {
357 __bt_get_service_list(value, dev_info);
358 } else if (!g_strcmp0(key, "ManufacturerDataLen")) {
359 dev_info->manufacturer_data.data_len = g_variant_get_uint16(value);
360 } else if (!g_strcmp0(key, "ManufacturerData")) {
361 manufacturer_data = g_byte_array_new();
362 g_variant_get(value, "ay", &char_value_iter);
363 while (g_variant_iter_loop(char_value_iter, "y", &char_value))
364 g_byte_array_append(manufacturer_data, &char_value, 1);
366 g_variant_iter_free(char_value_iter);
368 if (manufacturer_data) {
369 if (manufacturer_data->len > 0) {
370 memcpy(dev_info->manufacturer_data.data, manufacturer_data->data,
371 manufacturer_data->len);
374 g_byte_array_free(manufacturer_data, TRUE);
377 g_variant_iter_free(property_iter);
379 BT_DBG("trust: %d, paired: %d", trust, paired);
381 g_variant_unref(result);
383 if ((paired == FALSE) && (trust == FALSE)) {
386 return BLUETOOTH_ERROR_NOT_PAIRED;
389 _bt_convert_addr_string_to_type(dev_info->device_address.addr,
392 _bt_divide_device_class(&dev_info->device_class, cod);
394 g_strlcpy(dev_info->device_name.name, name,
395 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
397 dev_info->rssi = rssi;
398 dev_info->trust = trust;
399 dev_info->paired = paired;
400 dev_info->connected = connected;
401 ret = BLUETOOTH_ERROR_NONE;
408 void _bt_set_discovery_status(gboolean mode)
410 is_discovering = mode;
413 void _bt_set_cancel_by_user(gboolean value)
415 cancel_by_user = value;
418 gboolean _bt_get_cancel_by_user(void)
420 return cancel_by_user;
423 void _bt_adapter_set_status(bt_status_t status)
425 BT_INFO("adapter_status changed [%d] -> [%d]", adapter_status, status);
426 adapter_status = status;
429 bt_status_t _bt_adapter_get_status(void)
431 return adapter_status;
434 void _bt_adapter_set_le_status(bt_le_status_t status)
436 BT_INFO("adapter_le_status changed [%d] -> [%d]", adapter_le_status, status);
437 adapter_le_status = status;
440 bt_le_status_t _bt_adapter_get_le_status(void)
442 return adapter_le_status;
446 void _bt_set_le_intended_status(gboolean value)
448 is_le_intended = value;
451 static void __bt_phone_name_changed_cb(keynode_t *node, void *data)
453 char *phone_name = NULL;
459 if (vconf_keynode_get_type(node) == VCONF_TYPE_STRING) {
460 phone_name = vconf_keynode_get_str(node);
462 if (phone_name && strlen(phone_name) != 0) {
463 if (!g_utf8_validate(phone_name, -1,
464 (const char **)&ptr))
467 _bt_set_local_name(phone_name);
472 static void __bt_set_local_name(void)
474 bluetooth_device_name_t local_name;
475 char *phone_name = NULL;
479 if (_bt_get_local_name(&local_name) != BLUETOOTH_ERROR_NONE ||
480 (temp = strstr(local_name.name, "BlueZ")) != NULL) {
481 phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
486 if (strlen(phone_name) != 0) {
487 if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
490 _bt_set_local_name(phone_name);
496 static int __bt_set_enabled(void)
498 int adapter_status = BT_ADAPTER_DISABLED;
499 int result = BLUETOOTH_ERROR_NONE;
502 BT_DBG("g_source is removed");
503 g_source_remove(timer_id);
507 _bt_check_adapter(&adapter_status);
509 if (adapter_status == BT_ADAPTER_DISABLED) {
510 BT_ERR("Bluetoothd is not running");
511 return BLUETOOTH_ERROR_INTERNAL;
514 #if defined(TIZEN_PROFILE_MOBILE) || defined(TIZEN_PROFILE_IVI)
515 /* BT setting UI will control Mobile's visible mode. So in the FRWK...set the visible mode as off: */
516 if (_bt_set_discoverable_mode(
517 BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0) != BLUETOOTH_ERROR_NONE)
518 BT_ERR("Set connectable mode failed");
520 #ifdef TIZEN_PROFILE_TV
521 if (_bt_set_discoverable_mode(
522 BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0) != BLUETOOTH_ERROR_NONE)
523 BT_ERR("Fail to set discoverable mode");
527 /* Update Bluetooth Status to notify other modules */
528 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
529 BT_ERR("Set vconf failed\n");
531 if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
532 BT_ERR("Set vconf failed\n");
534 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
535 EVT_VAL_BT_ON) != ES_R_OK)
536 BT_ERR("Fail to set value");
538 /* Send enabled event to API */
539 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
540 g_variant_new("(i)", result));
542 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
543 _bt_audio_start_auto_connect(FALSE);
546 __bt_set_local_name();
547 _bt_set_discovery_status(FALSE);
549 return BLUETOOTH_ERROR_NONE;
552 void _bt_set_disabled(int result)
554 int power_off_status = 0;
557 int pm_ignore_mode = 0;
559 ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
560 BT_DBG("ret : %d, power_off_status : %d", ret, power_off_status);
562 ret_pm_ignore = vconf_get_int(VCONFKEY_PM_KEY_IGNORE, &pm_ignore_mode);
564 /* Update the vconf BT status in normal Deactivation case only */
565 if (ret == 0 && power_off_status == VCONFKEY_SYSMAN_POWER_OFF_NONE &&
566 ret_pm_ignore == 0 && pm_ignore_mode != VCONFKEY_PM_KEY_LOCK) {
568 BT_DBG("Update vconf for BT normal Deactivation");
570 if (result == BLUETOOTH_ERROR_TIMEOUT)
571 if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 1) != 0)
572 BT_ERR("Set vconf failed");
574 /* Update Bluetooth Status to notify other modules */
575 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
576 BT_ERR("Set vconf failed");
578 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
579 EVT_VAL_BT_OFF) != ES_R_OK)
580 BT_ERR("Fail to set value");
583 if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
584 BT_ERR("Set vconf failed\n");
586 _bt_cancel_queued_transfers();
587 _bt_adapter_set_status(BT_DEACTIVATED);
588 _bt_set_discovery_status(FALSE);
590 #ifndef TIZEN_FEATURE_BT_USB_DONGLE
591 if (_bt_adapter_get_le_status() != BT_LE_DEACTIVATED) {
593 /* Send disabled event */
594 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
595 g_variant_new("(i)", result));
596 #ifndef TIZEN_FEATURE_BT_USB_DONGLE
600 BT_INFO("Adapter disabled");
603 static int __bt_set_le_enabled(void)
606 int result = BLUETOOTH_ERROR_NONE;
609 /* Update Bluetooth Status to notify other modules */
610 if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_ON) != 0)
611 BT_ERR("Set vconf failed\n");
613 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
614 EVT_VAL_BT_LE_ON) != ES_R_OK)
615 BT_ERR("Fail to set value");
617 /* Send enabled event to API */
619 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
620 DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
622 status = _bt_adapter_get_status();
623 if (status == BT_DEACTIVATED) {
624 BT_INFO("BREDR is off, turn off PSCAN");
625 _bt_set_connectable(FALSE);
627 if (le_timer_id > 0) {
628 g_source_remove(le_timer_id);
632 /* Send enabled event to API */
633 _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_ENABLED,
634 g_variant_new("(i)", result));
636 __bt_set_local_name();
639 return BLUETOOTH_ERROR_NONE;
642 void _bt_set_le_disabled(int result)
644 int power_off_status;
647 ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
648 BT_DBG("ret : %d", ret);
649 BT_DBG("power_off_status : %d", power_off_status);
651 /* Update Bluetooth Status to notify other modules */
652 BT_DBG("Update vconf for BT LE normal Deactivation");
653 if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_OFF) != 0)
654 BT_ERR("Set vconf failed\n");
655 _bt_adapter_set_le_status(BT_LE_DEACTIVATED);
657 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
658 EVT_VAL_BT_LE_OFF) != ES_R_OK)
659 BT_ERR("Fail to set value");
661 /* Send disabled event */
662 _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_DISABLED,
663 g_variant_new("(i)", result));
666 void *_bt_get_adapter_agent(void)
668 return adapter_agent;
671 int _bt_enable_core(void)
675 GError *error = NULL;
677 proxy = __bt_get_core_proxy();
678 retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
680 /* Clean up the process */
681 result = g_dbus_proxy_call_sync(proxy,
684 G_DBUS_CALL_FLAGS_NONE,
691 BT_ERR("Bt core call failed(Error: %s)", error->message);
692 g_clear_error(&error);
694 BT_ERR("Bt core call failed");
695 return BLUETOOTH_ERROR_INTERNAL;
698 g_variant_unref(result);
699 return BLUETOOTH_ERROR_NONE;
702 #if defined(TIZEN_FEATURE_FLIGHTMODE_ENABLED) || (!defined(TIZEN_PROFILE_WEARABLE))
703 static void __bt_service_flight_ps_mode_cb(keynode_t *node, void *data)
705 gboolean flight_mode = FALSE;
706 int power_saving_mode = 0;
709 DBG_SECURE("key=%s", vconf_keynode_get_name(node));
710 type = vconf_keynode_get_type(node);
711 if (type == VCONF_TYPE_BOOL) {
712 flight_mode = vconf_keynode_get_bool(node);
713 if (flight_mode != TRUE) {
714 BT_ERR("Ignore the event");
717 } else if (type == VCONF_TYPE_INT) {
718 power_saving_mode = vconf_keynode_get_int(node);
719 if (power_saving_mode != 2) {
720 BT_ERR("Ignore the event");
724 BT_ERR("Invaild vconf key type : %d", type);
732 void _bt_service_register_vconf_handler(void)
736 #ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
737 if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
738 (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
739 BT_ERR("Unable to register key handler");
741 BT_DBG("Telephony is disabled");
744 #ifndef TIZEN_PROFILE_WEARABLE
745 if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
746 (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
747 BT_ERR("Unable to register key handler");
751 void _bt_service_unregister_vconf_handler(void)
755 #ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
756 vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
757 (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
760 #ifndef TIZEN_PROFILE_WEARABLE
761 vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
762 (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
766 static void __bt_state_event_handler(const char *event_name, bundle *data, void *user_data)
768 const char *bt_status = NULL;
769 const char *bt_le_status = NULL;
770 BT_DBG("bt state set event(%s) received", event_name);
772 bt_status = bundle_get_val(data, EVT_KEY_BT_STATE);
773 BT_DBG("bt_state: (%s)", bt_status);
775 bt_le_status = bundle_get_val(data, EVT_KEY_BT_LE_STATE);
776 BT_DBG("bt_state: (%s)", bt_le_status);
779 void _bt_handle_adapter_added(void)
783 bt_le_status_t le_status;
787 BT_DBG("g_source is removed");
788 g_source_remove(timer_id);
793 status = _bt_adapter_get_status();
794 le_status = _bt_adapter_get_le_status();
795 BT_DBG("status : %d", status);
796 BT_DBG("le_status : %d", le_status);
798 #ifndef TIZEN_FEATURE_BT_USB_DONGLE
799 adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
800 if (!adapter_agent) {
801 BT_ERR("Fail to register agent");
805 if (adapter_agent == NULL) {
806 adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
807 if (!adapter_agent) {
808 BT_ERR("Fail to register agent");
814 if (_bt_register_media_player() != BLUETOOTH_ERROR_NONE)
815 BT_ERR("Fail to register media player");
817 if (_bt_register_obex_server() != BLUETOOTH_ERROR_NONE)
818 BT_ERR("Fail to init obex server");
820 #ifdef TIZEN_BT_PAN_NAP_ENABLED
821 if (_bt_network_activate() != BLUETOOTH_ERROR_NONE)
822 BT_ERR("Fail to activate network");
825 /* add the vconf noti handler */
826 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
827 __bt_phone_name_changed_cb, NULL);
829 BT_ERR("Unable to register key handler");
831 if (le_status == BT_LE_ACTIVATING ||
832 status == BT_ACTIVATING) {
833 __bt_set_le_enabled();
834 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
837 if (status == BT_ACTIVATING) {
839 _bt_adapter_set_status(BT_ACTIVATED);
843 if (eventsystem_register_event(SYS_EVENT_BT_STATE, &status_reg_id,
844 (eventsystem_handler)__bt_state_event_handler, NULL) != ES_R_OK) {
845 BT_ERR("Fail to register system event");
849 void _bt_handle_adapter_removed(void)
853 _bt_adapter_set_status(BT_DEACTIVATED);
855 __bt_visibility_alarm_remove();
857 if (alarm_mgr.is_alarm_initialized == TRUE) {
859 alarm_mgr.is_alarm_initialized = FALSE;
860 g_list_free_full(alarm_mgr.g_alarm_list, alarm_data_free);
861 alarm_mgr.g_alarm_list = NULL;
864 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
865 _bt_audio_stop_auto_connect();
868 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
869 (vconf_callback_fn)__bt_phone_name_changed_cb);
871 ERR("vconf_ignore_key_changed failed\n");
873 #ifndef TIZEN_FEATURE_BT_USB_DONGLE
874 _bt_destroy_agent(adapter_agent);
875 adapter_agent = NULL;
877 if (is_recovery_mode == TRUE) {
878 /* Send disabled event */
879 _bt_set_disabled(BLUETOOTH_ERROR_NONE);
881 /* Will recover BT by bt-core, so set the mode as activating */
882 _bt_adapter_set_status(BT_ACTIVATING);
883 is_recovery_mode = FALSE;
885 _bt_reliable_terminate_service(NULL);
888 _bt_set_disabled(BLUETOOTH_ERROR_NONE);
891 if (eventsystem_unregister_event(status_reg_id) != ES_R_OK)
892 BT_ERR("Fail to unregister system event");
895 static gboolean __bt_enable_timeout_cb(gpointer user_data)
899 GError *error = NULL;
903 retv_if(_bt_adapter_get_status() == BT_ACTIVATED, FALSE);
905 BT_ERR("EnableAdapter is failed");
907 proxy = __bt_get_core_proxy();
911 /* Clean up the process */
912 result = g_dbus_proxy_call_sync(proxy,
915 G_DBUS_CALL_FLAGS_NONE,
922 BT_ERR("Bt core call failed(Error: %s)", error->message);
923 g_clear_error(&error);
925 BT_ERR("Bt core call failed");
930 g_variant_unref(result);
931 _bt_set_disabled(BLUETOOTH_ERROR_TIMEOUT);
933 #ifndef TIZEN_FEATURE_BT_USB_DONGLE
934 _bt_terminate_service(NULL);
940 static gboolean __bt_enable_le_timeout_cb(gpointer user_data)
944 GError *error = NULL;
948 retv_if(_bt_adapter_get_le_status() == BT_LE_ACTIVATED, FALSE);
950 BT_ERR("EnableAdapterLE is failed");
952 proxy = __bt_get_core_proxy();
956 /* Clean up the process */
957 result = g_dbus_proxy_call_sync(proxy,
960 G_DBUS_CALL_FLAGS_NONE,
967 BT_ERR("Bt core call failed(Error: %s)", error->message);
968 g_clear_error(&error);
970 BT_ERR("Bt core call failed");
974 g_variant_unref(result);
975 _bt_adapter_set_le_status(BT_LE_DEACTIVATED);
977 _bt_set_le_disabled(BLUETOOTH_ERROR_TIMEOUT);
979 if (_bt_adapter_get_status() == BT_DEACTIVATED)
980 _bt_terminate_service(NULL);
985 void _bt_adapter_start_le_enable_timer(void)
987 if (le_timer_id > 0) {
988 g_source_remove(le_timer_id);
992 le_timer_id = g_timeout_add(BT_ENABLE_TIMEOUT,
993 __bt_enable_le_timeout_cb, NULL);
998 void _bt_adapter_start_enable_timer(void)
1001 g_source_remove(timer_id);
1005 timer_id = g_timeout_add(BT_ENABLE_TIMEOUT,
1006 __bt_enable_timeout_cb, NULL);
1011 #ifdef TIZEN_PROFILE_TV
1012 static gboolean __bt_adapter_enabled_cb(gpointer user_data)
1017 _bt_adapter_set_status(BT_ACTIVATED);
1023 int _bt_enable_adapter_check_status(void)
1025 bt_status_t status = _bt_adapter_get_status();
1026 bt_le_status_t le_status = _bt_adapter_get_le_status();
1030 if (status == BT_ACTIVATING) {
1031 BT_ERR("Enabling in progress");
1032 return BLUETOOTH_ERROR_IN_PROGRESS;
1035 if (status == BT_ACTIVATED) {
1036 BT_ERR("Already enabled");
1037 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1040 if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
1041 BT_ERR("Disabling in progress");
1042 return BLUETOOTH_ERROR_DEVICE_BUSY;
1045 return BLUETOOTH_ERROR_NONE;
1048 int _bt_enable_adapter(void)
1051 GError *error = NULL;
1053 GVariant *result = NULL;
1054 bt_status_t status = _bt_adapter_get_status();
1055 bt_le_status_t le_status = _bt_adapter_get_le_status();
1059 if (status == BT_ACTIVATING) {
1060 BT_ERR("Enabling in progress");
1061 return BLUETOOTH_ERROR_IN_PROGRESS;
1064 if (status == BT_ACTIVATED) {
1065 BT_ERR("Already enabled");
1066 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1069 if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
1070 BT_ERR("Disabling in progress");
1071 return BLUETOOTH_ERROR_DEVICE_BUSY;
1074 _bt_adapter_set_status(BT_ACTIVATING);
1076 #ifdef TIZEN_PROFILE_TV
1078 int adapter_status = BT_ADAPTER_DISABLED;
1080 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
1081 BT_ERR("Set vconf failed");
1083 _bt_check_adapter(&adapter_status);
1084 if (adapter_status == BT_ADAPTER_ENABLED) {
1085 g_idle_add(__bt_adapter_enabled_cb, NULL);
1086 _bt_adapter_start_enable_timer();
1087 return BLUETOOTH_ERROR_NONE;
1092 proxy = __bt_get_core_proxy();
1094 return BLUETOOTH_ERROR_INTERNAL;
1096 if (le_status == BT_LE_ACTIVATED) {
1097 BT_INFO("LE Already enabled. Just turn on PSCAN");
1098 ret = _bt_set_connectable(TRUE);
1099 if (ret == BLUETOOTH_ERROR_NONE)
1100 _bt_adapter_set_status(BT_ACTIVATED);
1102 return BLUETOOTH_ERROR_INTERNAL;
1105 result = g_dbus_proxy_call_sync(proxy, "EnableAdapter",
1107 G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
1110 BT_ERR("EnableAdapterLe failed: %s", error->message);
1111 _bt_adapter_set_status(BT_DEACTIVATED);
1112 g_clear_error(&error);
1114 result = g_dbus_proxy_call_sync(proxy,
1117 G_DBUS_CALL_FLAGS_NONE,
1122 if (error != NULL) {
1123 BT_ERR("Bt core call failed(Error: %s)", error->message);
1124 g_clear_error(&error);
1126 g_variant_unref(result);
1127 #ifndef TIZEN_FEATURE_BT_USB_DONGLE
1128 /* Terminate myself */
1129 g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
1131 return BLUETOOTH_ERROR_INTERNAL;
1133 g_variant_unref(result);
1134 if (le_status == BT_LE_ACTIVATED)
1137 _bt_adapter_start_enable_timer();
1139 return BLUETOOTH_ERROR_NONE;
1142 static gboolean __bt_disconnect_all(void)
1145 GDBusConnection *conn;
1146 GDBusProxy *dev_proxy;
1147 gboolean ret = FALSE;
1149 GError *error = NULL;
1150 GArray *device_list;
1151 bluetooth_device_info_t info;
1153 char *device_path = NULL;
1154 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1159 conn = _bt_gdbus_get_system_gconn();
1161 device_list = g_array_new(FALSE, FALSE, sizeof(gchar));
1163 if (_bt_get_bonded_devices(&device_list)
1164 != BLUETOOTH_ERROR_NONE) {
1165 g_array_free(device_list, TRUE);
1169 size = (device_list->len) / sizeof(bluetooth_device_info_t);
1171 for (i = 0; i < size; i++) {
1173 info = g_array_index(device_list,
1174 bluetooth_device_info_t, i);
1176 if (info.connected != BLUETOOTH_CONNECTED_LINK_NONE) {
1177 BT_DBG("Found Connected device");
1178 _bt_convert_addr_type_to_string(address, info.device_address.addr);
1179 device_path = _bt_get_device_object_path(address);
1180 if (device_path == NULL)
1183 BT_DBG("Disconnecting : %s", device_path);
1185 dev_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1189 BT_DEVICE_INTERFACE,
1192 if (dev_proxy == NULL)
1195 result = g_dbus_proxy_call_sync(dev_proxy,
1198 G_DBUS_CALL_FLAGS_NONE,
1204 if (error != NULL) {
1205 BT_ERR("Disconnect call failed(Error: %s)", error->message);
1206 g_clear_error(&error);
1208 BT_ERR("Disconnect call failed");
1209 g_object_unref(dev_proxy);
1213 g_variant_unref(result);
1214 g_object_unref(dev_proxy);
1218 g_array_free(device_list, TRUE);
1224 static gboolean __bt_set_disabled_timeout_cb(gpointer user_data)
1227 _bt_set_disabled(BLUETOOTH_ERROR_NONE);
1233 int _bt_disable_cb(void)
1241 GError *error = NULL;
1243 _bt_adapter_set_status(BT_DEACTIVATING);
1245 bt_le_status_t le_status;
1246 le_status = _bt_adapter_get_le_status();
1247 BT_DBG("le_status : %d", le_status);
1248 if (le_status == BT_LE_ACTIVATED) {
1249 BT_INFO("LE is enabled. Just turn off PSCAN");
1251 if (_bt_is_discovering())
1252 _bt_cancel_discovery();
1254 if (_bt_is_connectable() == FALSE) {
1255 g_timeout_add(100, (GSourceFunc)__bt_set_disabled_timeout_cb, NULL);
1257 ret = _bt_set_connectable(FALSE);
1258 if (ret != BLUETOOTH_ERROR_NONE) {
1259 BT_ERR("_bt_set_connectable fail!");
1260 _bt_adapter_set_status(BT_ACTIVATED);
1261 return BLUETOOTH_ERROR_INTERNAL;
1266 proxy = __bt_get_core_proxy();
1267 retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
1269 result = g_dbus_proxy_call_sync(proxy,
1272 G_DBUS_CALL_FLAGS_NONE,
1278 if (error != NULL) {
1279 BT_ERR("Failed to DisableAdapter (Error: %s)", error->message);
1280 g_clear_error(&error);
1282 BT_ERR("Failed to DisableAdapter");
1283 _bt_adapter_set_status(BT_ACTIVATED);
1284 return BLUETOOTH_ERROR_INTERNAL;
1287 g_variant_unref(result);
1288 return BLUETOOTH_ERROR_NONE;
1291 int _bt_disable_adapter_check_status(void)
1293 bt_status_t status = _bt_adapter_get_status();
1297 if (status == BT_DEACTIVATING) {
1298 BT_DBG("Disabling in progress");
1299 return BLUETOOTH_ERROR_IN_PROGRESS;
1302 if (status == BT_DEACTIVATED) {
1303 BT_DBG("Already disabled");
1304 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1307 return BLUETOOTH_ERROR_NONE;
1310 int _bt_disable_adapter(void)
1315 if (_bt_adapter_get_status() == BT_DEACTIVATING) {
1316 BT_DBG("Disabling in progress");
1317 return BLUETOOTH_ERROR_IN_PROGRESS;
1320 if (_bt_adapter_get_status() == BT_DEACTIVATED) {
1321 BT_DBG("Already disabled");
1322 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1326 g_source_remove(timer_id);
1330 __bt_disconnect_all();
1331 ret = _bt_disable_cb();
1337 int _bt_recover_adapter(void)
1342 GError *error = NULL;
1344 if (_bt_adapter_get_status() == BT_DEACTIVATING) {
1345 BT_DBG("Disabling in progress");
1346 return BLUETOOTH_ERROR_IN_PROGRESS;
1349 if (_bt_adapter_get_status() == BT_DEACTIVATED) {
1350 BT_DBG("Already disabled");
1351 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1354 _bt_adapter_set_status(BT_DEACTIVATING);
1356 proxy = __bt_get_core_proxy();
1357 retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
1359 result = g_dbus_proxy_call_sync(proxy,
1362 G_DBUS_CALL_FLAGS_NONE,
1368 if (error != NULL) {
1369 BT_ERR("Failed to RecoverAdapter (Error: %s)", error->message);
1370 g_clear_error(&error);
1372 BT_ERR("Failed to RecoverAdapter");
1373 return BLUETOOTH_ERROR_INTERNAL;
1376 is_recovery_mode = TRUE;
1378 g_variant_unref(result);
1379 __bt_disconnect_all();
1382 return BLUETOOTH_ERROR_NONE;
1385 int _bt_reset_adapter(void)
1389 GError *error = NULL;
1393 proxy = __bt_get_core_proxy();
1395 return BLUETOOTH_ERROR_INTERNAL;
1397 result = g_dbus_proxy_call_sync(proxy,
1400 G_DBUS_CALL_FLAGS_NONE,
1406 if (error != NULL) {
1407 BT_ERR("Failed to ResetAdapter (Error: %s)", error->message);
1408 g_clear_error(&error);
1410 BT_ERR("Failed to ResetAdapter");
1411 return BLUETOOTH_ERROR_INTERNAL;
1414 g_variant_unref(result);
1415 /* Terminate myself */
1416 if (_bt_adapter_get_status() == BT_DEACTIVATED)
1417 g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
1419 return BLUETOOTH_ERROR_NONE;
1422 #ifndef TIZEN_PROFILE_TV
1423 int _bt_check_adapter(int *status)
1426 char *adapter_path = NULL;
1428 BT_CHECK_PARAMETER(status, return);
1430 *status = BT_ADAPTER_DISABLED;
1432 adapter_path = _bt_get_adapter_path();
1435 if (adapter_path != NULL)
1436 *status = BT_ADAPTER_ENABLED;
1438 g_free(adapter_path);
1439 return BLUETOOTH_ERROR_NONE;
1442 int _bt_check_adapter(int *status)
1445 GError *error = NULL;
1448 gboolean powered = FALSE;
1450 BT_CHECK_PARAMETER(status, return);
1452 *status = BT_ADAPTER_DISABLED;
1454 proxy = _bt_get_adapter_properties_proxy();
1455 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1457 result = g_dbus_proxy_call_sync(proxy,
1459 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1461 G_DBUS_CALL_FLAGS_NONE,
1467 BT_ERR("Failed to get local address");
1468 if (error != NULL) {
1469 BT_ERR("Failed to get local address (Error: %s)", error->message);
1470 g_clear_error(&error);
1472 return BLUETOOTH_ERROR_INTERNAL;
1475 g_variant_get(result, "(v)", &temp);
1476 powered = g_variant_get_boolean(temp);
1477 BT_DBG("powered: %d", powered);
1480 *status = BT_ADAPTER_ENABLED;
1482 g_variant_unref(result);
1483 g_variant_unref(temp);
1484 return BLUETOOTH_ERROR_NONE;
1488 int _bt_enable_adapter_le(void)
1492 GError *error = NULL;
1493 bt_status_t status = _bt_adapter_get_status();
1494 bt_le_status_t le_status = _bt_adapter_get_le_status();
1497 if (le_status == BT_LE_ACTIVATING) {
1498 BT_ERR("Enabling in progress");
1499 return BLUETOOTH_ERROR_IN_PROGRESS;
1502 if (le_status == BT_LE_ACTIVATED) {
1503 BT_ERR("Already enabled");
1504 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1507 if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
1508 BT_ERR("Disabling in progress");
1509 return BLUETOOTH_ERROR_DEVICE_BUSY;
1512 _bt_adapter_set_le_status(BT_LE_ACTIVATING);
1514 proxy = __bt_get_core_proxy();
1515 retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
1517 result = g_dbus_proxy_call_sync(proxy, "EnableAdapterLe",
1519 G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
1522 BT_ERR("EnableAdapterLe failed: %s", error->message);
1523 _bt_adapter_set_le_status(BT_DEACTIVATED);
1524 g_clear_error(&error);
1526 /* Clean up the process */
1527 result = g_dbus_proxy_call_sync(proxy,
1530 G_DBUS_CALL_FLAGS_NONE,
1536 BT_ERR("Bt core call failed");
1538 BT_ERR("EnableAdapterLE Failed %s", error->message);
1539 g_clear_error(&error);
1542 g_variant_unref(result);
1543 /* Terminate myself */
1544 if (_bt_adapter_get_status() == BT_DEACTIVATED)
1545 g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
1546 return BLUETOOTH_ERROR_INTERNAL;
1550 g_variant_unref(result);
1552 _bt_adapter_start_le_enable_timer();
1554 if (status == BT_ACTIVATED) {
1555 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
1556 __bt_set_le_enabled();
1558 BT_DBG("le status : %d", _bt_adapter_get_le_status());
1560 return BLUETOOTH_ERROR_NONE;
1563 int _bt_disable_adapter_le(void)
1567 bt_le_status_t bt_le_state;
1569 GError *error = NULL;
1571 bt_le_state = _bt_adapter_get_le_status();
1572 if (bt_le_state == BT_LE_DEACTIVATING) {
1573 BT_DBG("Disabling in progress");
1574 return BLUETOOTH_ERROR_IN_PROGRESS;
1577 if (bt_le_state == BT_LE_DEACTIVATED) {
1578 BT_DBG("Already disabled");
1579 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1582 _bt_adapter_set_le_status(BT_LE_DEACTIVATING);
1584 proxy = __bt_get_core_proxy();
1586 return BLUETOOTH_ERROR_INTERNAL;
1588 result = g_dbus_proxy_call_sync(proxy,
1591 G_DBUS_CALL_FLAGS_NONE,
1597 if (error != NULL) {
1598 BT_ERR("Bt core call failed (Error: %s)", error->message);
1599 g_clear_error(&error);
1601 BT_ERR("Bt core call failed");
1602 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
1603 return BLUETOOTH_ERROR_INTERNAL;
1606 g_variant_unref(result);
1607 _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
1608 BT_DBG("le status : %d", _bt_adapter_get_le_status());
1610 return BLUETOOTH_ERROR_NONE;
1613 int _bt_get_local_address(bluetooth_device_address_t *local_address)
1617 GError *error = NULL;
1618 const char *address;
1622 BT_CHECK_PARAMETER(local_address, return);
1624 proxy = _bt_get_adapter_properties_proxy();
1625 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1627 result = g_dbus_proxy_call_sync(proxy,
1629 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1631 G_DBUS_CALL_FLAGS_NONE,
1637 BT_ERR("Failed to get local address");
1638 if (error != NULL) {
1639 BT_ERR("Failed to get local address (Error: %s)", error->message);
1640 g_clear_error(&error);
1642 return BLUETOOTH_ERROR_INTERNAL;
1645 g_variant_get(result, "(v)", &temp);
1646 address = g_variant_get_string(temp, NULL);
1647 BT_DBG("Address:%s", address);
1650 _bt_convert_addr_string_to_type(local_address->addr, address);
1652 return BLUETOOTH_ERROR_INTERNAL;
1654 g_variant_unref(result);
1655 g_variant_unref(temp);
1656 return BLUETOOTH_ERROR_NONE;
1659 int _bt_get_local_version(bluetooth_version_t *local_version)
1662 const char *ver = NULL;
1664 int ret = BLUETOOTH_ERROR_NONE;
1668 BT_CHECK_PARAMETER(local_version, return);
1670 GError *error = NULL;
1672 proxy = _bt_get_adapter_properties_proxy();
1673 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1675 result = g_dbus_proxy_call_sync(proxy,
1677 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1679 G_DBUS_CALL_FLAGS_NONE,
1685 if (error != NULL) {
1686 BT_ERR("Failed to get local version (Error: %s)", error->message);
1687 g_clear_error(&error);
1689 BT_ERR("Failed to get local version");
1690 return BLUETOOTH_ERROR_INTERNAL;
1693 g_variant_get(result, "(v)", &temp);
1694 ver = g_variant_get_string(temp, NULL);
1695 BT_DBG("VERSION: %s", ver);
1697 if (ver && (strlen(ver) > 0)) {
1698 /* Check the utf8 valitation & Fill the NULL in the invalid location*/
1699 if (!g_utf8_validate(ver, -1, (const char **)&ptr))
1702 g_strlcpy(local_version->version, ver,
1703 BLUETOOTH_VERSION_LENGTH_MAX + 1);
1706 ret = BLUETOOTH_ERROR_INTERNAL;
1709 g_variant_unref(result);
1710 g_variant_unref(temp);
1714 int _bt_get_local_name(bluetooth_device_name_t *local_name)
1717 const char *name = NULL;
1719 int ret = BLUETOOTH_ERROR_NONE;
1722 GError *error = NULL;
1724 BT_CHECK_PARAMETER(local_name, return);
1726 proxy = _bt_get_adapter_properties_proxy();
1727 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1729 result = g_dbus_proxy_call_sync(proxy,
1731 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1733 G_DBUS_CALL_FLAGS_NONE,
1739 if (error != NULL) {
1740 BT_ERR("Failed to get local name (Error: %s)", error->message);
1741 g_clear_error(&error);
1743 BT_ERR("Failed to get local name");
1744 return BLUETOOTH_ERROR_INTERNAL;
1747 g_variant_get(result, "(v)", &temp);
1748 name = g_variant_get_string(temp, NULL);
1749 BT_DBG("LOCAL NAME:%s", name);
1751 if (name && (strlen(name) > 0)) {
1752 /* Check the utf8 valitation & Fill the NULL in the invalid location*/
1753 if (!g_utf8_validate(name, -1, (const char **)&ptr))
1756 g_strlcpy(local_name->name, name,
1757 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
1759 ret = BLUETOOTH_ERROR_INTERNAL;
1761 g_variant_unref(result);
1762 g_variant_unref(temp);
1766 int _bt_set_local_name(char *local_name)
1769 GError *error = NULL;
1773 BT_CHECK_PARAMETER(local_name, return);
1775 proxy = _bt_get_adapter_properties_proxy();
1777 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1779 if (!g_utf8_validate(local_name, -1, (const char **)&ptr))
1782 result = g_dbus_proxy_call_sync(proxy,
1784 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
1785 "Alias", g_variant_new("s", local_name)),
1786 G_DBUS_CALL_FLAGS_NONE,
1792 if (error != NULL) {
1793 BT_ERR("Failed to set Alias (Error: %s)", error->message);
1794 g_clear_error(&error);
1796 BT_ERR("Failed to set Alias");
1797 return BLUETOOTH_ERROR_INTERNAL;
1800 g_variant_unref(result);
1801 return BLUETOOTH_ERROR_NONE;
1804 int _bt_is_service_used(char *service_uuid, gboolean *used)
1807 GError *error = NULL;
1808 int ret = BLUETOOTH_ERROR_NONE;
1810 GVariant *temp = NULL;
1811 GVariantIter *iter = NULL;
1815 BT_CHECK_PARAMETER(service_uuid, return);
1816 BT_CHECK_PARAMETER(used, return);
1818 proxy = _bt_get_adapter_properties_proxy();
1819 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1821 result = g_dbus_proxy_call_sync(proxy,
1823 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1825 G_DBUS_CALL_FLAGS_NONE,
1831 if (error != NULL) {
1832 BT_ERR("Failed to get UUIDs (Error: %s)", error->message);
1833 g_clear_error(&error);
1835 BT_ERR("Failed to get UUIDs");
1836 return BLUETOOTH_ERROR_INTERNAL;
1839 g_variant_get(result, "(v)", &temp);
1840 g_variant_get(temp, "as", &iter);
1843 while (g_variant_iter_loop(iter, "&s", &uuid)) {
1844 if (strcasecmp(uuid, service_uuid) == 0) {
1849 g_variant_iter_free(iter);
1850 g_variant_unref(result);
1852 BT_DBG("Service Used? %d", *used);
1857 static gboolean __bt_get_discoverable_property(void)
1860 gboolean discoverable_v;
1861 GError *error = NULL;
1865 proxy = _bt_get_adapter_properties_proxy();
1866 retv_if(proxy == NULL, FALSE);
1868 result = g_dbus_proxy_call_sync(proxy,
1870 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
1872 G_DBUS_CALL_FLAGS_NONE,
1878 if (error != NULL) {
1879 BT_ERR("Failed to get Discoverable property (Error: %s)", error->message);
1880 g_clear_error(&error);
1882 BT_ERR("Failed to get Discoverable property");
1883 return BLUETOOTH_ERROR_INTERNAL;
1886 g_variant_get(result, "(v)", &temp);
1887 discoverable_v = g_variant_get_boolean(temp);
1888 BT_DBG("discoverable_v:%d", discoverable_v);
1890 g_variant_unref(result);
1891 g_variant_unref(temp);
1893 return discoverable_v;
1896 int _bt_get_discoverable_mode(int *mode)
1898 gboolean discoverable;
1899 unsigned int timeout;
1901 BT_CHECK_PARAMETER(mode, return);
1903 discoverable = __bt_get_discoverable_property();
1904 timeout = _bt_get_discoverable_timeout_property();
1906 if (discoverable == TRUE) {
1908 *mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
1910 *mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
1912 *mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
1914 return BLUETOOTH_ERROR_NONE;
1918 int _bt_set_discoverable_mode(int discoverable_mode, int timeout)
1920 int ret = BLUETOOTH_ERROR_NONE;
1923 GError *error = NULL;
1927 proxy = _bt_get_adapter_properties_proxy();
1929 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1931 #ifdef TIZEN_FEATURE_BT_DPM
1932 if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE &&
1933 _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
1934 _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT_HANDSFREE");
1935 return BLUETOOTH_ERROR_ACCESS_DENIED;
1937 if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE &&
1938 _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
1939 _bt_launch_dpm_popup("DPM_POLICY_DISABLE_BT");
1940 return BLUETOOTH_ERROR_ACCESS_DENIED;
1944 switch (discoverable_mode) {
1945 case BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE:
1950 case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
1955 case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
1960 return BLUETOOTH_ERROR_INVALID_PARAM;
1963 BT_INFO("Req. discoverable_mode : %d, timeout : %d",
1964 discoverable_mode, timeout);
1966 result = g_dbus_proxy_call_sync(proxy,
1968 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
1969 "Connectable", g_variant_new("b", pg_scan)),
1970 G_DBUS_CALL_FLAGS_NONE,
1976 if (error != NULL) {
1977 BT_ERR("Failed to set connectable property (Error: %s)", error->message);
1978 g_clear_error(&error);
1980 BT_ERR("Failed to set connectable property");
1981 return BLUETOOTH_ERROR_INTERNAL;
1983 g_variant_unref(result);
1984 result = g_dbus_proxy_call_sync(proxy,
1986 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE, "Discoverable",
1987 g_variant_new("b", inq_scan)),
1988 G_DBUS_CALL_FLAGS_NONE,
1994 if (error != NULL) {
1995 BT_ERR("Failed to set Discoverable property (Error: %s)", error->message);
1996 g_clear_error(&error);
1998 BT_ERR("Failed to set Discoverable property");
1999 return BLUETOOTH_ERROR_INTERNAL;
2001 g_variant_unref(result);
2002 result = g_dbus_proxy_call_sync(proxy,
2004 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
2005 "DiscoverableTimeout", g_variant_new("u", timeout)),
2006 G_DBUS_CALL_FLAGS_NONE,
2012 if (error != NULL) {
2013 BT_ERR("Failed to set DiscoverableTimeout property (Error: %s)", error->message);
2014 g_clear_error(&error);
2016 BT_ERR("Failed to set DiscoverableTimeout property");
2017 return BLUETOOTH_ERROR_INTERNAL;
2020 if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
2023 ret = __bt_set_visible_time(timeout);
2025 g_variant_unref(result);
2030 int _bt_start_discovery(void)
2033 GError *error = NULL;
2036 if (_bt_is_discovering() == TRUE) {
2037 BT_ERR("BT is already in discovering");
2038 return BLUETOOTH_ERROR_IN_PROGRESS;
2039 } else if (_bt_is_device_creating() == TRUE) {
2040 BT_ERR("Bonding device is going on");
2041 return BLUETOOTH_ERROR_DEVICE_BUSY;
2044 proxy = _bt_get_adapter_proxy();
2045 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2047 result = g_dbus_proxy_call_sync(proxy,
2050 G_DBUS_CALL_FLAGS_NONE,
2056 if (error != NULL) {
2057 BT_ERR("StartDiscovery failed (Error: %s)", error->message);
2058 g_clear_error(&error);
2060 BT_ERR("StartDiscovery failed");
2061 return BLUETOOTH_ERROR_INTERNAL;
2064 is_discovering = TRUE;
2065 cancel_by_user = FALSE;
2066 /* discovery status will be change in event */
2067 g_variant_unref(result);
2068 return BLUETOOTH_ERROR_NONE;
2071 int _bt_start_custom_discovery(bt_discovery_role_type_t role)
2075 GError *error = NULL;
2076 const gchar *disc_type;
2078 if (_bt_is_discovering() == TRUE) {
2079 BT_ERR("BT is already in discovering");
2080 return BLUETOOTH_ERROR_IN_PROGRESS;
2083 proxy = _bt_get_adapter_proxy();
2084 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2086 if (role == DISCOVERY_ROLE_BREDR)
2087 disc_type = "BREDR";
2088 else if (role == DISCOVERY_ROLE_LE)
2090 else if (role == DISCOVERY_ROLE_LE_BREDR)
2091 disc_type = "LE_BREDR";
2093 return BLUETOOTH_ERROR_INVALID_PARAM;
2095 result = g_dbus_proxy_call_sync(proxy,
2096 "StartCustomDiscovery",
2097 g_variant_new("s", disc_type),
2098 G_DBUS_CALL_FLAGS_NONE,
2104 if (error != NULL) {
2105 BT_ERR("StartCustomDiscovery failed (Error: %s)", error->message);
2106 g_clear_error(&error);
2108 BT_ERR("StartCustomDiscovery failed");
2109 return BLUETOOTH_ERROR_INTERNAL;
2112 is_discovering = TRUE;
2113 cancel_by_user = FALSE;
2114 /* discovery status will be change in event */
2115 g_variant_unref(result);
2116 return BLUETOOTH_ERROR_NONE;
2119 int _bt_cancel_discovery(void)
2122 GError *error = NULL;
2125 if (_bt_is_discovering() == FALSE) {
2126 BT_ERR("BT is not in discovering");
2127 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
2130 proxy = _bt_get_adapter_proxy();
2131 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2133 result = g_dbus_proxy_call_sync(proxy,
2136 G_DBUS_CALL_FLAGS_NONE,
2142 int ret = BLUETOOTH_ERROR_INTERNAL;
2143 if (error != NULL) {
2144 BT_ERR("StopDiscovery failed (Error: %s)", error->message);
2146 if (g_strrstr(error->message, "No discovery started"))
2147 ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
2149 g_clear_error(&error);
2151 BT_ERR("StopDiscovery failed");
2157 cancel_by_user = TRUE;
2158 /* discovery status will be change in event */
2159 g_variant_unref(result);
2160 return BLUETOOTH_ERROR_NONE;
2163 gboolean _bt_is_discovering(void)
2165 return is_discovering;
2168 gboolean _bt_is_connectable(void)
2171 GError *error = NULL;
2172 gboolean is_connectable = FALSE;
2176 proxy = _bt_get_adapter_properties_proxy();
2177 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2179 result = g_dbus_proxy_call_sync(proxy,
2181 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
2183 G_DBUS_CALL_FLAGS_NONE,
2189 if (error != NULL) {
2190 BT_ERR("Failed to get connectable property (Error: %s)", error->message);
2191 g_clear_error(&error);
2193 BT_ERR("Failed to get connectable property");
2194 return BLUETOOTH_ERROR_INTERNAL;
2197 g_variant_get(result, "(v)", &temp);
2198 is_connectable = g_variant_get_boolean(temp);
2199 BT_DBG("discoverable_v:%d", is_connectable);
2201 g_variant_unref(result);
2202 g_variant_unref(temp);
2204 BT_INFO("Get connectable [%d]", is_connectable);
2205 return is_connectable;
2208 int _bt_set_connectable(gboolean is_connectable)
2211 GError *error = NULL;
2214 if (__bt_is_factory_test_mode()) {
2215 BT_ERR("Unable to set connectable in factory binary !!");
2216 return BLUETOOTH_ERROR_NOT_SUPPORT;
2219 proxy = _bt_get_adapter_properties_proxy();
2221 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2223 result = g_dbus_proxy_call_sync(proxy,
2225 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE, "Connectable",
2226 g_variant_new("b", is_connectable)),
2227 G_DBUS_CALL_FLAGS_NONE,
2233 if (error != NULL) {
2234 BT_ERR("Failed to set connectable property (Error: %s)", error->message);
2235 g_clear_error(&error);
2237 BT_ERR("Failed to set connectable property");
2238 return BLUETOOTH_ERROR_INTERNAL;
2241 BT_INFO_C("### Set connectable [%d]", is_connectable);
2242 g_variant_unref(result);
2243 return BLUETOOTH_ERROR_NONE;
2246 gboolean _bt_get_discovering_property(bt_discovery_role_type_t discovery_type)
2249 gboolean discovering_v;
2250 GError *error = NULL;
2251 char *discovering_type = NULL;
2255 proxy = _bt_get_adapter_properties_proxy();
2256 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2258 if (discovery_type == DISCOVERY_ROLE_BREDR)
2259 discovering_type = "Discovering";
2260 else if (discovery_type == DISCOVERY_ROLE_LE)
2261 discovering_type = "LEDiscovering";
2263 result = g_dbus_proxy_call_sync(proxy,
2265 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
2267 G_DBUS_CALL_FLAGS_NONE,
2273 if (error != NULL) {
2274 BT_ERR("Failed to get discovering property (Error: %s)", error->message);
2275 g_clear_error(&error);
2277 BT_ERR("Failed to get discovering property");
2278 return BLUETOOTH_ERROR_INTERNAL;
2281 g_variant_get(result, "(v)", &temp);
2282 discovering_v = g_variant_get_boolean(temp);
2283 BT_DBG("discoverable_v:%d", discovering_v);
2285 g_variant_unref(result);
2286 g_variant_unref(temp);
2288 return discovering_v;
2291 unsigned int _bt_get_discoverable_timeout_property(void)
2294 unsigned int timeout_v;
2295 GError *error = NULL;
2299 proxy = _bt_get_adapter_properties_proxy();
2300 retv_if(proxy == NULL, 0);
2302 result = g_dbus_proxy_call_sync(proxy,
2304 g_variant_new("(ss)", BT_ADAPTER_INTERFACE,
2305 "DiscoverableTimeout"),
2306 G_DBUS_CALL_FLAGS_NONE,
2312 BT_ERR("Fail to get discoverable timeout");
2313 if (error != NULL) {
2314 BT_ERR("Fail to get discoverable timeout (Error: %s)", error->message);
2315 g_clear_error(&error);
2320 g_variant_get(result, "(v)", &temp);
2321 timeout_v = g_variant_get_uint32(temp);
2322 BT_DBG("discoverable_v:%d", timeout_v);
2324 g_variant_unref(result);
2325 g_variant_unref(temp);
2330 static bluetooth_device_info_t *__bt_parse_device_info(GVariantIter *item_iter)
2332 bluetooth_device_info_t *dev_info;
2335 GByteArray *manufacturer_data = NULL;
2337 GVariantIter *char_value_iter;
2339 dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
2341 while (g_variant_iter_loop(item_iter, "{sv}", &key, &value)) {
2346 if (!g_strcmp0(key, "Address")) {
2347 const char *address = NULL;
2348 address = g_variant_get_string(value, NULL);
2349 _bt_convert_addr_string_to_type(dev_info->device_address.addr,
2351 } else if (!g_strcmp0(key, "Class")) {
2353 cod = g_variant_get_uint32(value);
2354 _bt_divide_device_class(&dev_info->device_class, cod);
2355 } else if (!g_strcmp0(key, "Name")) {
2356 const char *name = NULL;
2357 name = g_variant_get_string(value, NULL);
2358 /* If there is no Alias */
2359 if (strlen(dev_info->device_name.name) == 0) {
2360 g_strlcpy(dev_info->device_name.name, name,
2361 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
2363 } else if (!g_strcmp0(key, "Alias")) {
2364 const char *alias = NULL;
2365 alias = g_variant_get_string(value, NULL);
2366 /* Overwrite the name */
2368 memset(dev_info->device_name.name, 0x00,
2369 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
2370 g_strlcpy(dev_info->device_name.name, alias,
2371 BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
2373 } else if (!g_strcmp0(key, "IsAliasSet")) {
2374 dev_info->is_alias_set = g_variant_get_boolean(value);
2375 } else if (!g_strcmp0(key, "Connected")) {
2376 dev_info->connected = g_variant_get_byte(value);
2377 } else if (!g_strcmp0(key, "Paired")) {
2378 dev_info->paired = g_variant_get_boolean(value);
2379 } else if (!g_strcmp0(key, "Trusted")) {
2380 dev_info->trust = g_variant_get_boolean(value);
2381 } else if (!g_strcmp0(key, "RSSI")) {
2382 dev_info->rssi = g_variant_get_int16(value);
2383 } else if (!g_strcmp0(key, "UUIDs")) {
2389 dev_info->service_index = 0;
2390 g_variant_get(value, "as", &iter);
2391 while (g_variant_iter_loop(iter, "s", &uuid)) {
2392 g_strlcpy(dev_info->uuids[i], uuid, BLUETOOTH_UUID_STRING_MAX);
2393 parts = g_strsplit(uuid, "-", -1);
2395 if (parts == NULL || parts[0] == NULL) {
2400 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
2405 dev_info->service_index = i;
2406 g_variant_iter_free(iter);
2407 } else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
2408 dev_info->manufacturer_data.data_len = g_variant_get_uint16(value);
2409 } else if (strcasecmp(key, "ManufacturerData") == 0) {
2410 manufacturer_data = g_byte_array_new();
2411 g_variant_get(value, "ay", &char_value_iter);
2412 while (g_variant_iter_loop(char_value_iter, "y", &char_value))
2413 g_byte_array_append(manufacturer_data, &char_value, 1);
2415 if (manufacturer_data) {
2416 if (manufacturer_data->len > 0)
2417 memcpy(dev_info->manufacturer_data.data, manufacturer_data->data, manufacturer_data->len);
2419 g_variant_iter_free(char_value_iter);
2420 g_byte_array_free(manufacturer_data, TRUE);
2427 static void __bt_extract_device_info(GVariantIter *iter,
2430 bluetooth_device_info_t *dev_info = NULL;
2431 char *object_path = NULL;
2432 GVariantIter *interface_iter;
2433 GVariantIter *svc_iter;
2434 char *interface_str = NULL;
2436 /* Parse the signature: oa{sa{sv}}} */
2437 while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
2440 if (object_path == NULL)
2443 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
2444 &interface_str, &svc_iter)) {
2445 if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
2446 BT_DBG("Found a device: %s", object_path);
2447 dev_info = __bt_parse_device_info(svc_iter);
2449 if (dev_info->paired == TRUE) {
2450 g_array_append_vals(*dev_list, dev_info,
2451 sizeof(bluetooth_device_info_t));
2455 g_free(interface_str);
2456 g_variant_iter_free(svc_iter);
2464 int _bt_get_bonded_devices(GArray **dev_list)
2467 GDBusConnection *conn;
2468 GDBusProxy *manager_proxy;
2469 GVariant *result = NULL;
2470 GVariantIter *iter = NULL;
2471 GError *error = NULL;
2473 conn = _bt_gdbus_get_system_gconn();
2474 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2476 manager_proxy = _bt_get_manager_proxy();
2477 retv_if(manager_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2479 result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
2481 G_DBUS_CALL_FLAGS_NONE,
2487 if (error != NULL) {
2488 BT_ERR("Failed to GetManagedObjects (Error: %s)", error->message);
2489 g_clear_error(&error);
2491 BT_ERR("Failed to Failed to GetManagedObjects");
2492 return BLUETOOTH_ERROR_INTERNAL;
2495 /* signature of GetManagedObjects: a{oa{sa{sv}}} */
2496 g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
2498 __bt_extract_device_info(iter, dev_list);
2499 g_variant_iter_free(iter);
2500 g_variant_unref(result);
2503 return BLUETOOTH_ERROR_NONE;
2506 int _bt_get_profile_connected_devices(char *profile_uuid, GArray **addr_list)
2509 GDBusConnection *conn;
2510 GDBusProxy *manager_proxy;
2511 GVariant *result = NULL;
2512 GVariant *result1 = NULL;
2513 GVariantIter *iter = NULL;
2514 GError *error = NULL;
2515 char *object_path = NULL;
2516 GVariantIter *interface_iter;
2517 char *interface_str = NULL;
2518 GDBusProxy *device_proxy = NULL;
2519 gboolean is_connected = FALSE;
2521 conn = _bt_gdbus_get_system_gconn();
2522 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2524 manager_proxy = _bt_get_manager_proxy();
2525 retv_if(manager_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2527 result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
2529 G_DBUS_CALL_FLAGS_NONE,
2535 if (error != NULL) {
2536 BT_ERR("Failed to GetManagedObjects (Error: %s)", error->message);
2537 g_clear_error(&error);
2540 BT_ERR("Failed to Failed to GetManagedObjects");
2541 return BLUETOOTH_ERROR_INTERNAL;
2544 /* signature of GetManagedObjects: a{oa{sa{sv}}} */
2545 g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
2547 /* Parse the signature: oa{sa{sv}}} */
2548 while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
2549 if (object_path == NULL)
2552 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
2553 &interface_str, NULL)) {
2554 if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
2555 BT_DBG("Found a device: %s", object_path);
2556 g_free(interface_str);
2558 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
2559 NULL, BT_BLUEZ_NAME,
2560 object_path, BT_DEVICE_INTERFACE, NULL, NULL);
2562 if (device_proxy == NULL) {
2563 BT_DBG("Device don't have this service");
2567 result1 = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
2568 g_variant_new("(s)", profile_uuid),
2569 G_DBUS_CALL_FLAGS_NONE,
2574 if (result1 == NULL) {
2575 BT_ERR("Error occured in Proxy call");
2577 BT_ERR("Error occured in Proxy call [%s]\n", error->message);
2578 g_error_free(error);
2581 g_object_unref(device_proxy);
2584 g_variant_get(result1, "(b)", &is_connected);
2586 if (is_connected == TRUE) {
2587 char address[BT_ADDRESS_STRING_SIZE];
2588 bluetooth_device_address_t *addr = NULL;
2590 _bt_convert_device_path_to_address(object_path, address);
2592 addr = g_malloc0(sizeof(bluetooth_device_address_t));
2593 _bt_convert_addr_string_to_type(addr->addr, address);
2595 g_array_append_vals(*addr_list, addr,
2596 sizeof(bluetooth_device_address_t));
2599 g_variant_unref(result1);
2600 g_object_unref(device_proxy);
2607 g_variant_unref(result);
2608 g_variant_iter_free(iter);
2611 return BLUETOOTH_ERROR_NONE;
2614 int _bt_get_bonded_device_info(bluetooth_device_address_t *device_address,
2615 bluetooth_device_info_t *dev_info)
2617 char *object_path = NULL;
2618 GDBusProxy *adapter_proxy;
2619 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2620 int ret = BLUETOOTH_ERROR_NONE;
2622 BT_CHECK_PARAMETER(device_address, return);
2623 BT_CHECK_PARAMETER(dev_info, return);
2625 adapter_proxy = _bt_get_adapter_proxy();
2626 retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2628 _bt_convert_addr_type_to_string(address, device_address->addr);
2630 object_path = _bt_get_device_object_path(address);
2632 retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
2634 ret = __bt_get_bonded_device_info(object_path, dev_info);
2635 g_free(object_path);
2640 int _bt_is_alias_set(bluetooth_device_address_t *device_address, gboolean *is_alias_set)
2642 char *object_path = NULL;
2643 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2644 gboolean alias_set = FALSE;
2646 GDBusConnection *conn;
2647 GDBusProxy *device_proxy;
2648 GError *error = NULL;
2649 GVariant *result = NULL;
2650 GVariant *temp = NULL;
2653 BT_CHECK_PARAMETER(device_address, return);
2654 BT_CHECK_PARAMETER(is_alias_set, return);
2656 _bt_convert_addr_type_to_string(address, device_address->addr);
2658 object_path = _bt_get_device_object_path(address);
2659 retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
2661 conn = _bt_gdbus_get_system_gconn();
2663 g_free(object_path);
2664 return BLUETOOTH_ERROR_INTERNAL;
2667 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
2671 BT_PROPERTIES_INTERFACE,
2673 if (device_proxy == NULL) {
2674 g_free(object_path);
2675 return BLUETOOTH_ERROR_INTERNAL;
2678 result = g_dbus_proxy_call_sync(device_proxy, "Get",
2679 g_variant_new("(ss)", BT_DEVICE_INTERFACE, "IsAliasSet"),
2680 G_DBUS_CALL_FLAGS_NONE,
2686 BT_ERR("Error occured in Proxy call");
2687 if (error != NULL) {
2688 BT_ERR("Getting is_alias_set property failed: [%s]\n", error->message);
2689 g_error_free(error);
2691 g_object_unref(device_proxy);
2692 g_free(object_path);
2693 return BLUETOOTH_ERROR_INTERNAL;
2696 g_variant_get(result, "(v)", &temp);
2697 alias_set = g_variant_get_boolean(temp);
2698 *is_alias_set = alias_set;
2699 BT_DBG("address: [%s] | *is_alias_set: %s", address, *is_alias_set ? "TRUE" : "FALSE");
2700 g_variant_unref(temp);
2701 g_variant_unref(result);
2702 g_object_unref(device_proxy);
2704 g_free(object_path);
2706 return BLUETOOTH_ERROR_NONE;
2709 int _bt_get_timeout_value(int *timeout)
2711 time_t current_time;
2714 /* Take current time */
2715 time(¤t_time);
2716 time_diff = difftime(current_time, visible_timer.start_time);
2718 BT_DBG("Time diff = %d\n", time_diff);
2720 *timeout = visible_timer.timeout - time_diff;
2722 return BLUETOOTH_ERROR_NONE;
2725 int _bt_set_le_privacy(gboolean set_privacy)
2728 GError *error = NULL;
2729 GVariant *result = NULL;
2731 if (__bt_is_factory_test_mode()) {
2732 BT_ERR("Unable to set le privacy in factory binary !!");
2733 return BLUETOOTH_ERROR_NOT_SUPPORT;
2736 if (_bt_adapter_get_status() != BT_ACTIVATED &&
2737 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2738 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2741 proxy = _bt_get_adapter_proxy();
2742 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2744 result = g_dbus_proxy_call_sync(proxy,
2746 g_variant_new("(b)", set_privacy),
2747 G_DBUS_CALL_FLAGS_NONE,
2753 if (error != NULL) {
2754 BT_ERR("Failed to SetLePrivacy (Error: %s)", error->message);
2755 g_clear_error(&error);
2757 BT_ERR("Failed to SetLePrivacy");
2758 return BLUETOOTH_ERROR_INTERNAL;
2761 g_variant_unref(result);
2762 BT_INFO("SetLePrivacy as %d", set_privacy);
2763 return BLUETOOTH_ERROR_NONE;
2766 int _bt_set_le_static_random_address(gboolean is_enable)
2769 GError *error = NULL;
2770 GVariant *result = NULL;
2772 if (__bt_is_factory_test_mode()) {
2773 BT_ERR("Unable to set le random address in factory binary !!");
2774 return BLUETOOTH_ERROR_NOT_SUPPORT;
2777 if (_bt_adapter_get_status() != BT_ACTIVATED &&
2778 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2779 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2782 proxy = _bt_get_adapter_proxy();
2783 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2785 result = g_dbus_proxy_call_sync(proxy,
2786 "SetLeStaticRandomAddress",
2787 g_variant_new("(b)", is_enable),
2788 G_DBUS_CALL_FLAGS_NONE,
2794 if (error != NULL) {
2795 BT_ERR("Failed to SetLeStaticRandomAddress (Error: %s)", error->message);
2796 g_clear_error(&error);
2798 BT_ERR("Failed to SetLeStaticRandomAddress");
2799 return BLUETOOTH_ERROR_INTERNAL;
2802 g_variant_unref(result);
2803 BT_INFO("SetLeStaticRandomAddress as %d", is_enable);
2804 return BLUETOOTH_ERROR_NONE;
2807 int _bt_set_manufacturer_data(bluetooth_manufacturer_data_t *m_data)
2810 GError *error = NULL;
2814 GVariantBuilder *builder;
2816 BT_CHECK_PARAMETER(m_data, return);
2818 if (_bt_adapter_get_status() != BT_ACTIVATED &&
2819 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2820 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2823 proxy = _bt_get_adapter_proxy();
2824 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2826 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
2828 for (i = 0; i < (m_data->data_len) + 2; i++)
2829 g_variant_builder_add(builder, "y", m_data->data[i]);
2831 val = g_variant_new("(ay)", builder);
2833 result = g_dbus_proxy_call_sync(proxy,
2834 "SetManufacturerData",
2836 G_DBUS_CALL_FLAGS_NONE,
2840 g_variant_builder_unref(builder);
2842 if (error != NULL) {
2843 BT_ERR("Failed to SetManufacturerData (Error: %s)", error->message);
2844 g_clear_error(&error);
2846 BT_ERR("Failed to SetManufacturerData");
2848 return BLUETOOTH_ERROR_INTERNAL;
2850 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
2852 for (i = 0; i < (m_data->data_len) + 2; i++)
2853 g_variant_builder_add(builder, "y", m_data->data[i]);
2855 val = g_variant_new("(ay)", builder);
2857 _bt_send_event(BT_ADAPTER_EVENT,
2858 BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
2861 BT_INFO("Set manufacturer data");
2863 g_variant_builder_unref(builder);
2864 g_variant_unref(result);
2866 return BLUETOOTH_ERROR_NONE;
2870 int _bt_service_set_alarm(int timeout, bt_set_alarm_cb call_back, void *user_data, alarm_id_t *alarm_id)
2872 int result = BLUETOOTH_ERROR_NONE;
2873 bt_service_alarm_t *alarm = NULL;
2875 if (!call_back || !alarm_id)
2876 return BLUETOOTH_ERROR_INVALID_PARAM;
2878 if (!alarm_mgr.is_alarm_initialized) {
2879 result = alarmmgr_init("bt-service");
2881 BT_ERR("Failed to initialize alarm = %d", result);
2882 result = BLUETOOTH_ERROR_INTERNAL;
2885 result = alarmmgr_set_cb(alarm_cb, NULL);
2887 BT_ERR("Failed to set the callback = %d", result);
2888 result = BLUETOOTH_ERROR_INTERNAL;
2891 alarm_mgr.is_alarm_initialized = TRUE;
2894 alarm = g_malloc0(sizeof(bt_service_alarm_t));
2896 return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
2898 result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, timeout,
2901 BT_ERR("Failed to create alarm error = %d", result);
2902 result = BLUETOOTH_ERROR_INTERNAL;
2906 alarm->alarm_id = *alarm_id;
2907 alarm->callback = call_back;
2908 alarm->user_data = user_data;
2910 alarm_mgr.g_alarm_list = g_list_append(alarm_mgr.g_alarm_list, alarm);
2911 result = BLUETOOTH_ERROR_NONE;
2916 static int alarm_cb(alarm_id_t alarm_id, void* user_param)
2919 bt_service_alarm_t *p_data;
2920 bt_set_alarm_cb callback = NULL;
2921 void *user_data = NULL;
2923 node = g_list_find_custom(alarm_mgr.g_alarm_list,
2924 GINT_TO_POINTER(alarm_id), compare_alarm);
2928 p_data = (bt_service_alarm_t *)node->data;
2929 alarm_mgr.g_alarm_list = g_list_delete_link(alarm_mgr.g_alarm_list,
2935 callback = p_data->callback;
2936 user_data = p_data->user_data;
2940 callback(alarm_id, user_data);
2945 int _bt_service_remove_alarm(alarm_id_t alarm_id)
2948 bt_service_alarm_t *p_data;
2949 list = g_list_find_custom(alarm_mgr.g_alarm_list, GINT_TO_POINTER(alarm_id), compare_alarm);
2952 alarmmgr_remove_alarm(alarm_id);
2953 p_data = (bt_service_alarm_t *)list->data;
2954 alarm_mgr.g_alarm_list = g_list_remove(alarm_mgr.g_alarm_list, list->data);
2961 gint compare_alarm(gconstpointer list_data, gconstpointer data)
2964 alarm_id_t alarm_id = (alarm_id_t)(uintptr_t)data;
2966 alarm_id_t alarm_id = (alarm_id_t)data;
2968 bt_service_alarm_t *p_data = (bt_service_alarm_t *)list_data;
2970 if (p_data->alarm_id == alarm_id)
2976 static void alarm_data_free(void *data)
2978 bt_service_alarm_t *p_data = (bt_service_alarm_t *)data;
2983 static gboolean _bt_adapter_request_delayed_cb(gpointer user_data)
2987 int function = (int)(uintptr_t)user_data;
2989 int function = (int)user_data;
2993 case BT_ENABLE_ADAPTER:
2994 result = _bt_enable_adapter();
2995 if (result != BLUETOOTH_ERROR_NONE) {
2996 BT_ERR("_bt_enable_adapter is failed");
2997 /* Send enabled event to API */
2998 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
2999 g_variant_new("(i)", result));
3002 case BT_DISABLE_ADAPTER:
3003 result = _bt_disable_adapter();
3004 if (result != BLUETOOTH_ERROR_NONE) {
3005 BT_ERR("_bt_disable_adapter is failed");
3006 /* Send disabled event to API */
3007 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
3008 g_variant_new("(i)", result));
3012 BT_ERR("function is NOT matched");
3019 int _bt_adapter_request_delayed(int function)
3024 case BT_ENABLE_ADAPTER:
3025 ret = _bt_enable_adapter_check_status();
3026 if (ret == BLUETOOTH_ERROR_NONE)
3027 _bt_adapter_set_status(BT_ACTIVATING);
3032 case BT_DISABLE_ADAPTER:
3033 ret = _bt_disable_adapter_check_status();
3034 if (ret == BLUETOOTH_ERROR_NONE)
3035 _bt_adapter_set_status(BT_DEACTIVATING);
3041 BT_ERR("function is NOT matched");
3042 return BLUETOOTH_ERROR_INTERNAL;
3046 g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void *)(uintptr_t)function);
3048 g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void *)function);
3051 return BLUETOOTH_ERROR_NONE;
3054 #ifdef TIZEN_PROFILE_TV
3055 int _bt_get_enable_timer_id(void)