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.
21 #include <eventsystem.h>
23 #include "bluetooth-api.h"
24 #include "bt-internal-types.h"
26 #include "bt-service-common.h"
27 #include "bt-service-event.h"
28 #include "bt-service-event-manager.h"
29 #include "bt-service-adapter.h"
30 #include "bt-service-util.h"
31 #include "bt-service-main.h"
41 bt_adapter_timer_t visible_timer = {0, };
43 static gboolean is_discovering;
44 static gboolean cancel_by_user;
45 static bt_status_t adapter_status = BT_DEACTIVATED;
46 static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
47 static guint timer_id = 0;
48 static guint le_timer_id = 0;
50 static uint status_reg_id;
52 static char *g_local_name;
53 static gboolean g_is_discoverable;
56 #define BT_DISABLE_TIME 500 /* 500 ms */
57 #define BT_DEFAULT_NAME "Tizen Emulator"
59 static gboolean __bt_adapter_enable_cb(gpointer user_data);
60 static gboolean __bt_adapter_disable_cb(gpointer user_data);
62 static gboolean __bt_timeout_handler(gpointer user_data)
64 int result = BLUETOOTH_ERROR_NONE;
68 /* Take current time */
70 time_diff = difftime(current_time, visible_timer.start_time);
72 /* Send event to application */
73 _bt_send_event(BT_ADAPTER_EVENT,
74 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
75 g_variant_new("(in)", result, time_diff));
77 if (visible_timer.timeout <= time_diff) {
78 g_source_remove(visible_timer.event_id);
79 visible_timer.event_id = 0;
80 visible_timer.timeout = 0;
82 if (!TIZEN_PROFILE_WEARABLE) {
83 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
84 BT_ERR("Set vconf failed\n");
92 static int __bt_visibility_alarm_cb(alarm_id_t alarm_id, void* user_param)
94 BT_DBG("__bt_visibility_alarm_cb - alram id = [%d] \n", alarm_id);
96 int result = BLUETOOTH_ERROR_NONE;
99 if (alarm_id != visible_timer.alarm_id)
102 if (visible_timer.event_id) {
103 _bt_send_event(BT_ADAPTER_EVENT,
104 BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
105 g_variant_new("(in)", result, timeout));
106 g_source_remove(visible_timer.event_id);
107 visible_timer.event_id = 0;
108 visible_timer.timeout = 0;
110 if (!TIZEN_PROFILE_WEARABLE) {
111 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
112 BT_ERR("Set vconf failed\n");
115 /* Switch Off visibility in Bluez */
116 _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
117 visible_timer.alarm_id = 0;
121 static void __bt_visibility_alarm_create()
126 result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, visible_timer.timeout,
129 BT_ERR("Failed to create alarm error = %d\n", result);
131 BT_DBG("Alarm created = %d\n", alarm_id);
132 visible_timer.alarm_id = alarm_id;
136 static void __bt_visibility_alarm_remove()
138 if (visible_timer.event_id > 0) {
139 g_source_remove(visible_timer.event_id);
140 visible_timer.event_id = 0;
143 if (visible_timer.alarm_id > 0) {
144 alarmmgr_remove_alarm(visible_timer.alarm_id);
145 visible_timer.alarm_id = 0;
149 int __bt_set_visible_time(int timeout)
153 __bt_visibility_alarm_remove();
155 visible_timer.timeout = timeout;
157 if (!TIZEN_PROFILE_WEARABLE) {
158 if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
159 BT_ERR("Set vconf failed");
163 return BLUETOOTH_ERROR_NONE;
165 if (!visible_timer.alarm_init) {
166 /* Set Alarm timer to switch off BT */
167 result = alarmmgr_init("bt-service");
169 return BLUETOOTH_ERROR_INTERNAL;
171 visible_timer.alarm_init = TRUE;
174 result = alarmmgr_set_cb(__bt_visibility_alarm_cb, NULL);
176 return BLUETOOTH_ERROR_INTERNAL;
178 /* Take start time */
179 time(&(visible_timer.start_time));
180 visible_timer.event_id = g_timeout_add_seconds(1,
181 __bt_timeout_handler, NULL);
183 __bt_visibility_alarm_create();
185 return BLUETOOTH_ERROR_NONE;
188 void _bt_set_discovery_status(gboolean mode)
190 is_discovering = mode;
193 void _bt_set_cancel_by_user(gboolean value)
195 cancel_by_user = value;
198 gboolean _bt_get_cancel_by_user(void)
200 return cancel_by_user;
203 void _bt_adapter_set_status(bt_status_t status)
205 BT_INFO("adapter_status changed [%d] -> [%d]", adapter_status, status);
206 adapter_status = status;
209 bt_status_t _bt_adapter_get_status(void)
211 return adapter_status;
214 void _bt_adapter_set_le_status(bt_le_status_t status)
216 BT_INFO("adapter_le_status changed [%d] -> [%d]", adapter_le_status, status);
217 adapter_le_status = status;
220 bt_le_status_t _bt_adapter_get_le_status(void)
222 return adapter_le_status;
225 static void __bt_phone_name_changed_cb(keynode_t *node, void *data)
227 char *phone_name = NULL;
233 if (vconf_keynode_get_type(node) == VCONF_TYPE_STRING) {
234 phone_name = vconf_keynode_get_str(node);
236 if (phone_name && strlen(phone_name) != 0) {
237 if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
240 _bt_set_local_name(phone_name);
245 static void __bt_set_visible_mode(void)
249 if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
250 BT_ERR("Fail to get the timeout value");
253 if (_bt_set_discoverable_mode(
254 BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
255 timeout) != BLUETOOTH_ERROR_NONE) {
256 if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
257 BT_ERR("Set vconf failed");
260 if (_bt_set_discoverable_mode(
261 BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
262 timeout) != BLUETOOTH_ERROR_NONE) {
263 BT_ERR("Set connectable mode failed");
268 static void __bt_set_local_name(void)
270 char *phone_name = NULL;
273 phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
278 if (strlen(phone_name) != 0) {
279 if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
282 _bt_set_local_name(phone_name);
287 static int __bt_set_enabled(void)
290 int result = BLUETOOTH_ERROR_NONE;
292 if (TIZEN_PROFILE_MOBILE) {
293 __bt_set_visible_mode();
294 } else if (TIZEN_PROFILE_TV) {
295 if (_bt_set_discoverable_mode(
296 BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0) != BLUETOOTH_ERROR_NONE)
297 BT_ERR("Fail to set discoverable mode");
299 __bt_set_local_name();
301 /* Update Bluetooth Status to notify other modules */
302 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
303 BT_ERR("Set vconf failed\n");
305 if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
306 BT_ERR("Set vconf failed\n");
308 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
309 EVT_VAL_BT_ON) != ES_R_OK)
310 BT_ERR("Fail to set value");
313 /* Send enabled event to API */
314 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
315 g_variant_new("(i)", result));
318 return BLUETOOTH_ERROR_NONE;
321 void _bt_set_disabled(int result)
323 int power_off_status = 0;
326 int pm_ignore_mode = 0;
328 ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
329 BT_DBG("ret : %d, power_off_status : %d", ret, power_off_status);
331 ret_pm_ignore = vconf_get_int(VCONFKEY_PM_KEY_IGNORE, &pm_ignore_mode);
333 /* Update the vconf BT status in normal Deactivation case only */
334 if (ret == 0 && power_off_status == VCONFKEY_SYSMAN_POWER_OFF_NONE &&
335 ret_pm_ignore == 0 && pm_ignore_mode != VCONFKEY_PM_KEY_LOCK) {
337 BT_DBG("Update vconf for BT normal Deactivation");
339 if (result == BLUETOOTH_ERROR_TIMEOUT)
340 if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 1) != 0)
341 BT_ERR("Set vconf failed");
343 /* Update Bluetooth Status to notify other modules */
344 if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
345 BT_ERR("Set vconf failed");
347 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
348 EVT_VAL_BT_OFF) != ES_R_OK)
349 BT_ERR("Fail to set value");
352 if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
353 BT_ERR("Set vconf failed\n");
355 _bt_adapter_set_status(BT_DEACTIVATED);
357 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
358 g_variant_new("(i)", result));
360 BT_INFO("Adapter disabled");
363 static int __bt_set_le_enabled(void)
366 int result = BLUETOOTH_ERROR_NONE;
369 __bt_set_local_name();
371 /* Update Bluetooth Status to notify other modules */
372 if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_ON) != 0)
373 BT_ERR("Set vconf failed\n");
375 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
376 EVT_VAL_BT_LE_ON) != ES_R_OK)
377 BT_ERR("Fail to set value");
379 /* Send enabled event to API */
381 _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
382 DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
384 status = _bt_adapter_get_status();
385 if (status == BT_DEACTIVATED) {
386 BT_INFO("BREDR is off, turn off PSCAN");
387 _bt_set_connectable(FALSE);
389 if (le_timer_id > 0) {
390 g_source_remove(le_timer_id);
394 /* Send enabled event to API */
395 _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_ENABLED,
396 g_variant_new("(i)", result));
399 return BLUETOOTH_ERROR_NONE;
402 void _bt_set_le_disabled(int result)
404 int power_off_status;
407 ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
408 BT_DBG("ret : %d", ret);
409 BT_DBG("power_off_status : %d", power_off_status);
411 /* Update Bluetooth Status to notify other modules */
412 BT_DBG("Update vconf for BT LE normal Deactivation");
413 if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_OFF) != 0)
414 BT_ERR("Set vconf failed\n");
415 _bt_adapter_set_le_status(BT_LE_DEACTIVATED);
417 if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
418 EVT_VAL_BT_LE_OFF) != ES_R_OK)
419 BT_ERR("Fail to set value");
421 /* Send disabled event */
422 _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_DISABLED,
423 g_variant_new_int32(result));
426 static void __bt_service_flight_ps_mode_cb(keynode_t *node, void *data)
428 gboolean flight_mode = FALSE;
429 int power_saving_mode = 0;
432 DBG_SECURE("key=%s", vconf_keynode_get_name(node));
433 type = vconf_keynode_get_type(node);
434 if (type == VCONF_TYPE_BOOL) {
435 flight_mode = vconf_keynode_get_bool(node);
436 if (flight_mode != TRUE) {
437 BT_ERR("Ignore the event");
440 } else if (type == VCONF_TYPE_INT) {
441 power_saving_mode = vconf_keynode_get_int(node);
442 if (power_saving_mode != 2) {
443 BT_ERR("Ignore the event");
447 BT_ERR("Invaild vconf key type : %d", type);
452 void _bt_service_register_vconf_handler(void)
456 if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
457 if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
458 (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
459 BT_ERR("Unable to register key handler");
461 BT_DBG("Telephony is disabled");
464 #ifdef ENABLE_TIZEN_2_4
465 if (!TIZEN_PROFILE_WEARABLE && vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
466 (vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
467 BT_ERR("Unable to register key handler");
471 void _bt_service_unregister_vconf_handler(void)
475 if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
476 vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
477 (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
480 #ifdef ENABLE_TIZEN_2_4
481 if (!TIZEN_PROFILE_WEARABLE)
482 vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
483 (vconf_callback_fn)__bt_service_flight_ps_mode_cb);
487 static void __bt_state_event_handler(const char *event_name, bundle *data, void *user_data)
489 #ifdef ENABLE_TIZEN_2_4
490 const char *bt_status = NULL;
491 const char *bt_le_status = NULL;
492 BT_DBG("bt state set event(%s) received", event_name);
493 bt_status = bundle_get_val(data, EVT_KEY_BT_STATE);
494 BT_DBG("bt_state: (%s)", bt_status);
496 bt_le_status = bundle_get_val(data, EVT_KEY_BT_LE_STATE);
497 BT_DBG("bt_state: (%s)", bt_le_status);
501 static gboolean __bt_adapter_enable_cb(gpointer user_data)
505 bt_le_status_t le_status;
509 BT_DBG("g_source is removed");
510 g_source_remove(timer_id);
514 status = _bt_adapter_get_status();
515 le_status = _bt_adapter_get_le_status();
516 BT_DBG("status : %d", status);
517 BT_DBG("le_status : %d", le_status);
519 /* add the vconf noti handler */
520 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
521 __bt_phone_name_changed_cb, NULL);
523 BT_ERR("Unable to register key handler");
525 if (le_status == BT_LE_ACTIVATING ||
526 status == BT_ACTIVATING) {
527 __bt_set_le_enabled();
528 _bt_adapter_set_le_status(BT_LE_ACTIVATED);
531 if (status == BT_ACTIVATING) {
533 _bt_adapter_set_status(BT_ACTIVATED);
535 #ifdef ENABLE_TIZEN_2_4
539 _bt_service_register_vconf_handler();
542 if (eventsystem_register_event(SYS_EVENT_BT_STATE, &status_reg_id,
543 (eventsystem_handler)__bt_state_event_handler, NULL) != ES_R_OK) {
544 BT_ERR("Fail to register system event");
547 _bt_delete_event_timer(BT_EVENT_TIMER_ENABLE);
552 static gboolean __bt_adapter_disable_cb(gpointer user_data)
556 _bt_adapter_set_status(BT_DEACTIVATED);
557 #ifdef ENABLE_TIZEN_2_4
561 __bt_visibility_alarm_remove();
563 if (visible_timer.alarm_init) {
565 visible_timer.alarm_init = FALSE;
568 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
569 (vconf_callback_fn)__bt_phone_name_changed_cb);
571 BT_ERR("vconf_ignore_key_changed failed\n");
573 _bt_reliable_terminate_service(NULL);
575 if (eventsystem_unregister_event(status_reg_id) != ES_R_OK)
576 BT_ERR("Fail to unregister system event");
578 _bt_delete_event_timer(BT_EVENT_TIMER_DISABLE);
583 static gboolean __bt_adapter_device_found_cb(gpointer user_data)
586 int result = BLUETOOTH_ERROR_NONE;
587 GVariant *param = NULL;
588 GVariant *uuids = NULL;
589 GVariant *manufacturer_data = NULL;
590 GVariantBuilder *builder = NULL;
591 bt_remote_dev_info_t *dev_info;
595 BT_DBG("found count: %d", found_cnt);
597 if (found_cnt >= _bt_get_sample_device_number()) {
598 BT_DBG("Finish creating devices");
602 BT_DBG("[%d] device found", found_cnt);
604 dev_info = _bt_get_sample_device(found_cnt);
605 if (dev_info == NULL) {
606 BT_DBG("Fail to get the sample device");
610 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
611 for (i = 0; i < dev_info->uuid_count; i++) {
612 g_variant_builder_add(builder, "s",
615 uuids = g_variant_new("as", builder);
616 g_variant_builder_unref(builder);
618 manufacturer_data = g_variant_new_from_data(
619 G_VARIANT_TYPE_BYTESTRING,
620 dev_info->manufacturer_data,
621 dev_info->manufacturer_data_len,
624 param = g_variant_new("(isunsbub@asn@ay)", result,
633 dev_info->manufacturer_data_len,
636 _bt_send_event(BT_ADAPTER_EVENT,
637 BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
640 _bt_free_device_info(dev_info);
646 _bt_delete_event_timer(BT_EVENT_TIMER_FOUND_DEVICE);
648 param = g_variant_new("(i)", result);
650 _bt_send_event(BT_ADAPTER_EVENT,
651 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
654 is_discovering = FALSE;
660 static gboolean __bt_adapter_start_discovery_cb(gpointer user_data)
662 int result = BLUETOOTH_ERROR_NONE;
663 GVariant *param = NULL;
665 BT_DBG("Discovery started");
667 param = g_variant_new("(i)", result);
669 _bt_send_event(BT_ADAPTER_EVENT,
670 BLUETOOTH_EVENT_DISCOVERY_STARTED,
673 _bt_delete_event_timer(BT_EVENT_TIMER_START_DISCOVERY);
677 _bt_create_event_timer(BT_EVENT_TIMER_FOUND_DEVICE, 500,
678 __bt_adapter_device_found_cb, NULL);
683 static gboolean __bt_adapter_stop_discovery_cb(gpointer user_data)
685 int result = BLUETOOTH_ERROR_NONE;
686 GVariant *param = NULL;
688 BT_DBG("Discovery stopped");
690 param = g_variant_new("(i)", result);
692 _bt_send_event(BT_ADAPTER_EVENT,
693 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
696 _bt_delete_event_timer(BT_EVENT_TIMER_FOUND_DEVICE);
697 _bt_delete_event_timer(BT_EVENT_TIMER_STOP_DISCOVERY);
702 static gboolean __bt_enable_timeout_cb(gpointer user_data)
706 retv_if(_bt_adapter_get_status() == BT_ACTIVATED, FALSE);
708 BT_ERR("EnableAdapter is failed");
710 _bt_set_disabled(BLUETOOTH_ERROR_TIMEOUT);
712 _bt_terminate_service(NULL);
717 static gboolean __bt_enable_le_timeout_cb(gpointer user_data)
721 retv_if(_bt_adapter_get_le_status() == BT_LE_ACTIVATED, FALSE);
723 BT_ERR("EnableAdapterLE is failed");
725 _bt_adapter_set_le_status(BT_LE_DEACTIVATED);
727 _bt_set_le_disabled(BLUETOOTH_ERROR_TIMEOUT);
729 if (_bt_adapter_get_status() == BT_DEACTIVATED)
730 _bt_terminate_service(NULL);
735 void _bt_adapter_start_le_enable_timer(void)
737 if (le_timer_id > 0) {
738 g_source_remove(le_timer_id);
742 le_timer_id = g_timeout_add(BT_ENABLE_TIMEOUT,
743 __bt_enable_le_timeout_cb, NULL);
748 void _bt_adapter_start_enable_timer(void)
751 g_source_remove(timer_id);
755 timer_id = g_timeout_add(BT_ENABLE_TIMEOUT,
756 __bt_enable_timeout_cb, NULL);
761 int _bt_enable_adapter(void)
763 bt_status_t status = _bt_adapter_get_status();
764 bt_le_status_t le_status = _bt_adapter_get_le_status();
768 if (status == BT_ACTIVATING) {
769 BT_ERR("Enabling in progress");
770 return BLUETOOTH_ERROR_IN_PROGRESS;
773 if (status == BT_ACTIVATED) {
774 BT_ERR("Already enabled");
775 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
778 if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
779 BT_ERR("Disabling in progress");
780 return BLUETOOTH_ERROR_DEVICE_BUSY;
783 _bt_adapter_set_status(BT_ACTIVATING);
785 _bt_create_event_timer(BT_EVENT_TIMER_ENABLE, 2000,
786 __bt_adapter_enable_cb, NULL);
788 return BLUETOOTH_ERROR_NONE;
791 int _bt_disable_adapter(void)
795 if (_bt_adapter_get_status() == BT_DEACTIVATING) {
796 BT_DBG("Disabling in progress");
797 return BLUETOOTH_ERROR_IN_PROGRESS;
800 if (_bt_adapter_get_status() == BT_DEACTIVATED) {
801 BT_DBG("Already disabled");
802 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
806 g_source_remove(timer_id);
810 _bt_adapter_set_status(BT_DEACTIVATING);
812 _bt_create_event_timer(BT_EVENT_TIMER_DISABLE, 1000,
813 __bt_adapter_disable_cb, NULL);
816 return BLUETOOTH_ERROR_NONE;
819 int _bt_recover_adapter(void)
821 return BLUETOOTH_ERROR_NOT_SUPPORT;
824 int _bt_reset_adapter(void)
827 g_source_remove(timer_id);
831 _bt_create_event_timer(BT_EVENT_TIMER_DISABLE, 1000,
832 __bt_adapter_disable_cb, NULL);
834 return BLUETOOTH_ERROR_NONE;
837 int _bt_check_adapter(int *status)
840 BT_CHECK_PARAMETER(status, return);
842 *status = adapter_status;
844 return BLUETOOTH_ERROR_NONE;
847 int _bt_enable_adapter_le(void)
850 bt_status_t status = _bt_adapter_get_status();
851 bt_le_status_t le_status = _bt_adapter_get_le_status();
853 if (le_status == BT_LE_ACTIVATING) {
854 BT_ERR("Enabling in progress");
855 return BLUETOOTH_ERROR_IN_PROGRESS;
858 if (le_status == BT_LE_ACTIVATED) {
859 BT_ERR("Already enabled");
860 return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
863 if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
864 BT_ERR("Disabling in progress");
865 return BLUETOOTH_ERROR_DEVICE_BUSY;
868 __bt_set_le_enabled();
870 BT_DBG("le status : %d", _bt_adapter_get_le_status());
872 return BLUETOOTH_ERROR_NONE;
875 int _bt_disable_adapter_le(void)
878 bt_le_status_t bt_le_state;
880 bt_le_state = _bt_adapter_get_le_status();
881 if (bt_le_state == BT_LE_DEACTIVATING) {
882 BT_DBG("Disabling in progress");
883 return BLUETOOTH_ERROR_IN_PROGRESS;
886 if (bt_le_state == BT_LE_DEACTIVATED) {
887 BT_DBG("Already disabled");
888 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
891 _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
893 BT_DBG("le status : %d", _bt_adapter_get_le_status());
895 return BLUETOOTH_ERROR_NONE;
898 int _bt_get_local_address(bluetooth_device_address_t *local_address)
900 const char *address = "11:22:33:44:55:66";
902 BT_CHECK_PARAMETER(local_address, return);
904 BT_DBG("Address:%s", address);
906 _bt_convert_addr_string_to_type(local_address->addr, address);
908 return BLUETOOTH_ERROR_NONE;
911 int _bt_get_local_version(bluetooth_version_t *local_version)
913 const char *ver = "Tizen BT emul v0.1";
915 BT_CHECK_PARAMETER(local_version, return);
917 g_strlcpy(local_version->version, ver, BLUETOOTH_VERSION_LENGTH_MAX + 1);
919 return BLUETOOTH_ERROR_NONE;
922 int _bt_get_local_name(bluetooth_device_name_t *local_name)
924 BT_CHECK_PARAMETER(local_name, return);
926 if (g_local_name != NULL)
927 g_local_name = g_strdup(BT_DEFAULT_NAME);
929 g_strlcpy(local_name->name, g_local_name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
931 return BLUETOOTH_ERROR_NONE;
934 int _bt_set_local_name(char *local_name)
936 BT_CHECK_PARAMETER(local_name, return);
938 g_free(g_local_name);
939 g_local_name = g_strdup(local_name);
941 return BLUETOOTH_ERROR_NONE;
944 int _bt_is_service_used(char *service_uuid, gboolean *used)
946 BT_CHECK_PARAMETER(service_uuid, return);
947 BT_CHECK_PARAMETER(used, return);
951 return BLUETOOTH_ERROR_NOT_SUPPORT;
954 int _bt_get_discoverable_mode(int *mode)
956 BT_CHECK_PARAMETER(mode, return);
958 if (g_is_discoverable == TRUE) {
959 if (visible_timer.timeout == 0)
960 *mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
962 *mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
964 *mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
966 return BLUETOOTH_ERROR_NONE;
970 int _bt_set_discoverable_mode(int discoverable_mode, int timeout)
972 int ret = BLUETOOTH_ERROR_NONE;
974 switch (discoverable_mode) {
975 case BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE:
976 g_is_discoverable = FALSE;
979 case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
981 g_is_discoverable = TRUE;
983 case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
984 g_is_discoverable = TRUE;
987 return BLUETOOTH_ERROR_INVALID_PARAM;
990 BT_INFO("Req. discoverable_mode : %d, timeout : %d",
991 discoverable_mode, timeout);
993 if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
996 ret = __bt_set_visible_time(timeout);
1001 int _bt_start_discovery(void)
1003 return _bt_start_custom_discovery(DISCOVERY_ROLE_LE_BREDR);
1006 int _bt_start_custom_discovery(bt_discovery_role_type_t role)
1010 if (_bt_is_discovering() == TRUE) {
1011 BT_ERR("BT is already in discovering");
1012 return BLUETOOTH_ERROR_IN_PROGRESS;
1015 is_discovering = TRUE;
1016 cancel_by_user = FALSE;
1018 _bt_create_event_timer(BT_EVENT_TIMER_START_DISCOVERY, 100,
1019 __bt_adapter_start_discovery_cb, NULL);
1021 return BLUETOOTH_ERROR_NONE;
1024 int _bt_cancel_discovery(void)
1026 if (_bt_is_discovering() == FALSE) {
1027 BT_ERR("BT is not in discovering");
1028 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1031 is_discovering = FALSE;
1032 cancel_by_user = TRUE;
1035 _bt_delete_event_timer(BT_EVENT_TIMER_START_DISCOVERY);
1036 _bt_delete_event_timer(BT_EVENT_TIMER_FOUND_DEVICE);
1038 _bt_create_event_timer(BT_EVENT_TIMER_STOP_DISCOVERY, 100,
1039 __bt_adapter_stop_discovery_cb, NULL);
1041 return BLUETOOTH_ERROR_NONE;
1044 gboolean _bt_is_discovering(void)
1046 return is_discovering;
1049 gboolean _bt_is_connectable(void)
1054 int _bt_set_connectable(gboolean is_connectable)
1056 return BLUETOOTH_ERROR_NOT_SUPPORT;
1059 int _bt_get_bonded_devices(GArray **dev_list)
1061 /* Should implement this */
1063 return BLUETOOTH_ERROR_NONE;
1066 int _bt_get_bonded_device_info(bluetooth_device_address_t *device_address,
1067 bluetooth_device_info_t *dev_info)
1069 BT_CHECK_PARAMETER(device_address, return);
1070 BT_CHECK_PARAMETER(dev_info, return);
1072 /* Should implement this */
1073 return BLUETOOTH_ERROR_NONE;
1076 int _bt_get_timeout_value(int *timeout)
1078 time_t current_time;
1081 /* Take current time */
1082 time(¤t_time);
1083 time_diff = difftime(current_time, visible_timer.start_time);
1085 BT_DBG("Time diff = %d\n", time_diff);
1087 *timeout = visible_timer.timeout - time_diff;
1089 return BLUETOOTH_ERROR_NONE;
1092 int _bt_set_le_privacy(gboolean set_privacy)
1094 return BLUETOOTH_ERROR_NOT_SUPPORT;
1097 int _bt_set_manufacturer_data(bluetooth_manufacturer_data_t *m_data)
1099 BT_CHECK_PARAMETER(m_data, return);
1101 return BLUETOOTH_ERROR_NOT_SUPPORT;