4 * Copyright (c) 2015 -2016 Samsung Electronics Co., Ltd All Rights Reserved.
6 * Contact: Anupam Roy <anupam.r@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
33 #include "bt-hal-log.h"
34 #include "bt-hal-msg.h"
35 #include "bt-hal-utils.h"
36 #include "bt-hal-adapter-le.h"
37 #include "bt-hal-adapter-dbus-handler.h"
38 #include "bt-hal-dbus-common-utils.h"
40 #include "bt-internal-types.h"
42 #define BT_ENABLE_TIMEOUT 20000 /* 20 seconds */
43 #define BT_CORE_NAME "org.projectx.bt_core"
44 #define BT_CORE_PATH "/org/projectx/bt_core"
45 #define BT_CORE_INTERFACE "org.projectx.btcore"
47 static GDBusProxy *core_proxy = NULL;
48 static GDBusConnection *system_conn = NULL;
49 static handle_stack_msg event_cb = NULL;
51 handle_stack_msg _bt_get_adapter_event_cb(void)
59 GDBusConnection *__bt_hal_get_system_gconn(void)
62 if (system_conn == NULL)
63 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
69 GDBusProxy *_bt_init_core_proxy(void)
71 GDBusConnection *conn;
74 conn = __bt_hal_get_system_gconn();
78 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
94 static GDBusProxy *__bt_get_core_proxy(void)
96 return (core_proxy) ? core_proxy : _bt_init_core_proxy();
99 /* To send stack event to hal-bluetooth handler */
100 void _bt_hal_dbus_store_stack_msg_cb(handle_stack_msg cb)
105 int _bt_hal_enable_core(void)
110 GError *error = NULL;
112 proxy = __bt_get_core_proxy();
114 return BT_HAL_ERROR_INTERNAL;
116 /* Clean up the process */
117 result = g_dbus_proxy_call_sync(proxy,
120 G_DBUS_CALL_FLAGS_NONE,
127 ERR("Bt core call failed(Error: %s)", error->message);
128 g_clear_error(&error);
130 ERR("Bt core call failed");
131 return BT_HAL_ERROR_INTERNAL;
134 g_variant_unref(result);
135 return BT_HAL_ERROR_NONE;
138 static gboolean __bt_hal_send_adapter_event(gpointer user_data)
140 struct hal_ev_adapter_state_changed ev;
141 gboolean *enable = (gboolean *)user_data;
144 ev.state = HAL_POWER_ON;
146 ev.state = HAL_POWER_OFF;
149 event_cb = _bt_get_adapter_event_cb();
152 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
158 static gboolean __bt_hal_send_le_event(gpointer user_data)
160 struct hal_ev_le_state_changed ev;
161 gboolean *enable = (gboolean *)user_data;
164 ev.state = HAL_POWER_ON;
166 ev.state = HAL_POWER_OFF;
169 event_cb = _bt_get_adapter_event_cb();
172 event_cb(HAL_EV_LE_STATE_CHANGED, &ev, sizeof(ev));
179 int _bt_hal_dbus_enable_adapter(void)
182 GError *error = NULL;
183 GVariant *result = NULL;
184 unsigned char powered = 0;
188 int le_value = VCONFKEY_BT_LE_STATUS_OFF;
189 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &le_value))
190 ERR("fail to get vconf key!");
192 if (_bt_hal_get_adapter_powered_state(&powered) == BT_STATUS_FAIL)
193 ERR("_bt_hal_get_adapter_powered_state failed");
195 /*if LE is enabled and bluez is UP , send event from here and return.*/
196 if ((le_value == VCONFKEY_BT_LE_STATUS_ON) && (powered == 1)) {
197 gboolean *user_data = g_new0(int, 1);
199 g_idle_add(__bt_hal_send_adapter_event, (gpointer)user_data);
200 return BT_STATUS_SUCCESS;
203 if (TIZEN_FEATURE_BT_USB_DONGLE && powered == 1) {
204 gboolean *user_data = g_new0(int, 1);
206 g_idle_add(__bt_hal_send_adapter_event, (gpointer)user_data);
207 return BT_STATUS_SUCCESS;
210 proxy = __bt_get_core_proxy();
213 DBG("_bt_hal_dbus_enable_adapter: Core proxy get failed!!!");
214 return BT_STATUS_FAIL;
217 _bt_hal_set_adapter_request_state(TRUE);
218 _bt_hal_set_le_request_state(TRUE);
219 result = g_dbus_proxy_call_sync(proxy, "EnableAdapter",
221 G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
224 DBG("EnableAdapter failed: %s", error->message);
225 g_clear_error(&error);
227 _bt_hal_set_adapter_request_state(FALSE);
228 _bt_hal_set_le_request_state(FALSE);
229 result = g_dbus_proxy_call_sync(proxy,
232 G_DBUS_CALL_FLAGS_NONE,
238 DBG("Bt core call failed(Error: %s)", error->message);
239 g_clear_error(&error);
241 g_variant_unref(result);
243 /* TODO: Terminate bluetooth service or not, need to check */
244 /*g_idle_add((GSourceFunc)_bt_terminate_service, NULL);*/
245 return BT_STATUS_FAIL;
249 g_variant_unref(result);
250 return BT_STATUS_SUCCESS;
253 int _bt_hal_dbus_disable_adapter(void)
256 GError *error = NULL;
257 GVariant *result = NULL;
260 proxy = __bt_get_core_proxy();
263 DBG("_bt_hal_dbus_enable_adapter: Core proxy get failed!!!");
264 return BT_STATUS_FAIL;
267 result = g_dbus_proxy_call_sync(proxy, "DisableAdapter",
269 G_DBUS_CALL_FLAGS_NONE, -1,
272 DBG("DisableAdapter failed: %s", error->message);
273 g_clear_error(&error);
275 g_variant_unref(result);
277 /* TODO: Terminate bluetooth service or not, need to check */
278 /*g_idle_add((GSourceFunc)_bt_terminate_service, NULL);*/
279 return BT_STATUS_FAIL;
283 g_variant_unref(result);
284 return BT_STATUS_SUCCESS;
287 int _bt_hal_dbus_recover_adapter(void)
290 GVariant *result = NULL;
291 GError *error = NULL;
294 proxy = __bt_get_core_proxy();
297 DBG("_bt_hal_dbus_recover_adapter: Core proxy get failed!!!");
298 return BT_STATUS_FAIL;
301 result = g_dbus_proxy_call_sync(proxy, "RecoverAdapter",
303 G_DBUS_CALL_FLAGS_NONE, -1,
306 DBG("RecoverAdapter failed: %s", error->message);
307 g_clear_error(&error);
309 return BT_STATUS_FAIL;
313 g_variant_unref(result);
314 return BT_STATUS_SUCCESS;
318 int _bt_hal_dbus_enable_le(void)
321 GError *error = NULL;
322 GVariant *result = NULL;
323 int adapter_value = VCONFKEY_BT_STATUS_OFF;
324 unsigned char powered = 0;
328 if (vconf_get_int(VCONFKEY_BT_STATUS, &adapter_value) != 0)
329 ERR("fail to get vconf key!");
331 if (_bt_hal_get_adapter_powered_state(&powered) == BT_STATUS_FAIL)
332 ERR("_bt_hal_get_adapter_powered_state failed");
334 if ((adapter_value == VCONFKEY_BT_STATUS_ON) && (powered == 1)) {
335 gboolean *user_data = g_new0(int, 1);
337 g_idle_add(__bt_hal_send_le_event, (gpointer)user_data);
338 return BT_STATUS_SUCCESS;
341 proxy = __bt_get_core_proxy();
344 DBG("_bt_hal_dbus_enable_le: Core proxy get failed!!!");
345 return BT_STATUS_FAIL;
347 _bt_hal_set_le_request_state(TRUE);
349 result = g_dbus_proxy_call_sync(proxy, "EnableAdapterLe",
351 G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
354 DBG("EnableAdapterLe failed: %s", error->message);
355 g_clear_error(&error);
357 result = g_dbus_proxy_call_sync(proxy,
360 G_DBUS_CALL_FLAGS_NONE,
365 _bt_hal_set_le_request_state(FALSE);
367 DBG("Bt core call failed(Error: %s)", error->message);
368 g_clear_error(&error);
370 g_variant_unref(result);
372 return BT_STATUS_FAIL;
376 g_variant_unref(result);
377 return BT_STATUS_SUCCESS;
380 int _bt_hal_dbus_disable_le(void)
383 GError *error = NULL;
384 GVariant *result = NULL;
385 int adapter_value = VCONFKEY_BT_STATUS_OFF;
388 if (vconf_get_int(VCONFKEY_BT_STATUS, &adapter_value) != 0)
389 ERR("fail to get vconf key!");
391 if (adapter_value == VCONFKEY_BT_STATUS_ON) {
392 gboolean *user_data = g_new0(int, 1);
394 g_idle_add(__bt_hal_send_le_event, (gpointer)user_data);
395 return BT_STATUS_SUCCESS;
398 proxy = __bt_get_core_proxy();
401 DBG("_bt_hal_dbus_disable_le: Core proxy get failed!!!");
402 return BT_STATUS_FAIL;
405 result = g_dbus_proxy_call_sync(proxy, "DisableAdapterLe",
407 G_DBUS_CALL_FLAGS_NONE, -1,
410 DBG("DisableAdapter failed: %s", error->message);
411 g_clear_error(&error);
413 g_variant_unref(result);
414 return BT_STATUS_FAIL;
420 g_variant_unref(result);
421 return BT_STATUS_SUCCESS;
426 int _bt_hal_dbus_reset_adapter(void)
430 GError *error = NULL;
433 proxy = __bt_get_core_proxy();
435 return BT_STATUS_FAIL;
437 result = g_dbus_proxy_call_sync(proxy,
440 G_DBUS_CALL_FLAGS_NONE,
447 ERR("Failed to ResetAdapter (Error: %s)", error->message);
448 g_clear_error(&error);
450 ERR("Failed to ResetAdapter");
451 return BT_STATUS_FAIL;
454 g_variant_unref(result);
455 return BT_STATUS_SUCCESS;
459 int _bt_hal_dbus_start_discovery(gboolean is_custom,
460 bt_disc_role_type_t role)
463 GError *error = NULL;
465 const gchar *disc_type;
466 DBG("Discovery Type: Is Custom : [%s]", is_custom ? "TRUE" : "FALSE");
468 proxy = _bt_hal_get_adapter_proxy();
470 DBG("Adapter proxy get failed!!!");
471 return BT_STATUS_FAIL;
475 if (role == BT_DISC_ROLE_BREDR)
477 else if (role == BT_DISC_ROLE_LE)
479 else if (role == BT_DISC_ROLE_DUAL)
480 disc_type = "LE_BREDR";
482 return BT_STATUS_PARM_INVALID;
484 result = g_dbus_proxy_call_sync(proxy,
485 "StartCustomDiscovery",
486 g_variant_new("s", disc_type),
487 G_DBUS_CALL_FLAGS_NONE,
492 result = g_dbus_proxy_call_sync(proxy,
495 G_DBUS_CALL_FLAGS_NONE,
502 ERR("StartDiscovery failed (Error: %s)", error->message);
503 g_clear_error(&error);
505 ERR("StartDiscovery failed");
506 return BT_STATUS_FAIL;
509 /* discovery status will be change in event */
511 g_variant_unref(result);
512 return BT_STATUS_SUCCESS;
515 int _bt_hal_dbus_stop_discovery(void)
518 GError *error = NULL;
522 proxy = _bt_hal_get_adapter_proxy();
524 DBG("_bt_hal_dbus_stop_discovery: Adapter proxy get failed!!!");
525 return BT_STATUS_FAIL;
528 result = g_dbus_proxy_call_sync(proxy,
531 G_DBUS_CALL_FLAGS_NONE,
538 ERR("StopDiscovery failed (Error: %s)", error->message);
539 g_clear_error(&error);
541 ERR("StopDiscovery failed");
542 return BT_STATUS_FAIL;
545 /* discovery status will be change in event */
547 g_variant_unref(result);
548 return BT_STATUS_SUCCESS;
551 static gboolean __bt_adapter_all_properties_cb(gpointer user_data)
553 GVariant *result = user_data;
554 GVariantIter *property_iter;
558 /* Buffer and propety count management */
559 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
560 struct hal_ev_adapter_props_changed *ev = (void*) buf;
562 gchar *address = NULL;
564 unsigned int cod = 0;
565 gboolean discoverable;
566 gboolean connectable;
567 unsigned int scan_mode = BT_SCAN_MODE_NONE;
568 unsigned int disc_timeout;
570 gboolean is_discovering;
571 gboolean is_le_discovering;
572 uint8_t ipsp_initialized;
575 unsigned int pairable_timeout;
576 gboolean scan_mode_property_update = FALSE;
580 memset(buf, 0, sizeof(buf));
583 ev->status = BT_STATUS_SUCCESS;
585 DBG("@@Start parsing properties");
586 g_variant_get(result, "(a{sv})", &property_iter);
587 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
588 if (!g_strcmp0(key, "Address")) {
591 address = (gchar *) g_variant_get_string(value, NULL);
592 DBG("Address [%s]", address);
593 _bt_hal_convert_addr_string_to_type(bdaddr, address);
594 size += __bt_insert_hal_properties(buf + size,
595 HAL_PROP_ADAPTER_ADDR, sizeof(bdaddr), bdaddr);
597 } else if (!g_strcmp0(key, "Alias")) {
598 name = (gchar *) g_variant_get_string(value, NULL);
599 DBG("Alias [%s]", name);
600 size += __bt_insert_hal_properties(buf + size,
601 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
603 } else if (!g_strcmp0(key, "Class")) {
604 cod = g_variant_get_uint32(value);
605 DBG("Class [%d]", cod);
606 size += __bt_insert_hal_properties(buf + size,
607 HAL_PROP_ADAPTER_CLASS, sizeof(unsigned int), &cod);
609 } else if (!g_strcmp0(key, "Discoverable")) {
610 discoverable = g_variant_get_boolean(value);
611 DBG("Discoverable [%d]", discoverable);
613 scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
614 scan_mode_property_update = TRUE;
615 } else if (!g_strcmp0(key, "DiscoverableTimeout")) {
616 disc_timeout = g_variant_get_uint32(value);
617 DBG("Discoverable Timeout [%d]", disc_timeout);
618 size += __bt_insert_hal_properties(buf + size,
619 HAL_PROP_ADAPTER_DISC_TIMEOUT, sizeof(unsigned int), &disc_timeout);
621 } else if (!g_strcmp0(key, "Connectable")) {
622 connectable = g_variant_get_boolean(value);
623 DBG("Connectable [%d]", connectable);
624 if (scan_mode == BT_SCAN_MODE_NONE)
625 scan_mode = BT_SCAN_MODE_CONNECTABLE;
626 scan_mode_property_update = TRUE;
627 } else if (!g_strcmp0(key, "Version")) {
628 version = (gchar *) g_variant_get_string(value, NULL);
629 DBG("Version [%s]", version);
630 size += __bt_insert_hal_properties(buf + size,
631 HAL_PROP_ADAPTER_VERSION, strlen(version) + 1, version);
633 } else if (!g_strcmp0(key, "Name")) {
634 name = (gchar *) g_variant_get_string(value, NULL);
635 DBG("Name [%s]", name);
636 size += __bt_insert_hal_properties(buf + size,
637 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
639 } else if (!g_strcmp0(key, "Powered")) {
640 powered = g_variant_get_boolean(value);
641 DBG("Powered = [%d]", powered);
642 } else if (!g_strcmp0(key, "Pairable")) {
643 pairable = (g_variant_get_boolean(value) ? 1 : 0);
644 DBG("Pairable [%d]", pairable);
645 size += __bt_insert_hal_properties(buf + size,
646 HAL_PROP_ADAPTER_PAIRABLE, sizeof(uint8_t), &pairable);
648 } else if (!g_strcmp0(key, "PairableTimeout")) {
649 pairable_timeout = g_variant_get_uint32(value);
650 DBG("Pairable Timeout = [%d]", pairable_timeout);
651 size += __bt_insert_hal_properties(buf + size,
652 HAL_PROP_ADAPTER_PAIRABLE_TIMEOUT, sizeof(unsigned int), &pairable_timeout);
654 } else if (!g_strcmp0(key, "UUIDs")) {
659 size1 = g_variant_get_size(value);
660 int num_props_tmp = ev->num_props;
662 uuid_value = (char **)g_variant_get_strv(value, &size1);
663 for (i = 0; uuid_value[i] != NULL; i++)
665 /* UUID collection */
666 uint8_t uuids[HAL_UUID_LEN * uuid_count];
667 for (i = 0; uuid_value[i] != NULL; i++) {
668 char *uuid_str = NULL;
669 uint8_t uuid[HAL_UUID_LEN];
670 uuid_str = g_strdup(uuid_value[i]);
671 DBG("UUID string [%s]\n", uuid_str);
672 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
673 memcpy(uuids + i * HAL_UUID_LEN, uuid, HAL_UUID_LEN);
676 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_UUIDS,
677 (HAL_UUID_LEN * uuid_count),
679 ev->num_props = num_props_tmp + 1;
682 } else if (!g_strcmp0(key, "Discovering")) {
683 is_discovering = g_variant_get_boolean(value);
684 DBG("Discovering = [%d]", is_discovering);
685 } else if (!g_strcmp0(key, "LEDiscovering")) {
686 is_le_discovering = g_variant_get_boolean(value);
687 DBG("LE Discovering = [%d]", is_le_discovering);
688 } else if (!g_strcmp0(key, "Modalias")) {
689 char *modalias = NULL;
690 g_variant_get(value, "s", &modalias);
691 DBG("Adapter ModAlias [%s]", modalias);
692 size += __bt_insert_hal_properties(buf + size,
693 HAL_PROP_ADAPTER_MODALIAS, strlen(modalias) + 1, modalias);
696 } else if (!g_strcmp0(key, "SupportedLEFeatures")) {
697 DBG("LE Supported features");
700 GVariantIter *iter = NULL;
701 bt_local_le_features_t le_features;
702 gboolean le_features_present = FALSE;
704 memset(&le_features, 0x00, sizeof(le_features));
706 g_variant_get(value, "as", &iter);
708 while (g_variant_iter_loop(iter, "s", &name)) {
709 DBG("name = %s", name);
710 g_variant_iter_loop(iter, "s", &val);
711 DBG("Value = %s", val);
712 _bt_hal_update_le_feature_support(name, val, &le_features);
713 le_features_present = TRUE;
715 g_variant_iter_free(iter);
717 if (le_features_present) {
718 size += __bt_insert_hal_properties(buf + size,
719 HAL_PROP_ADAPTER_LOCAL_LE_FEAT, sizeof(le_features), &le_features);
722 DBG("le supported features values are NOT provided by Stack");
725 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
726 ipsp_initialized = (g_variant_get_boolean(value) ? 1 : 0);
727 DBG("IPSP Initialized = %d", ipsp_initialized);
728 size += __bt_insert_hal_properties(buf + size,
729 HAL_PROP_ADAPTER_IPSP_INITIALIZED, sizeof(uint8_t), &ipsp_initialized);
732 ERR("Unhandled Property:[%s]", key);
736 if (scan_mode_property_update) {
737 size += __bt_insert_hal_properties(buf + size,
738 HAL_PROP_ADAPTER_SCAN_MODE, sizeof(int), &scan_mode);
743 event_cb = _bt_get_adapter_event_cb();
745 ERR("event_cb is NULL");
750 DBG("Send Adapter properties changed event to HAL user,"
751 " Num Prop [%d] total size [%zd]", ev->num_props, size);
752 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
755 g_variant_unref(result);
759 static int __bt_hal_dbus_get_all_adapter_properties(void)
763 GError *error = NULL;
767 proxy = _bt_hal_get_adapter_properties_proxy();
769 DBG("Adapter Properties proxy get failed!!!");
770 return BT_STATUS_FAIL;
773 result = g_dbus_proxy_call_sync(proxy,
775 g_variant_new("(s)", BT_HAL_ADAPTER_INTERFACE),
776 G_DBUS_CALL_FLAGS_NONE,
783 ERR("Failed to get all adapter properties (Error: %s)", error->message);
784 g_clear_error(&error);
786 ERR("Failed to get all adapter properties");
787 return BT_STATUS_FAIL;
790 DBG("Got All properties from Bluez Stack!!, time to start parsing");
792 * As we need to provide async callback to user from HAL, simply schedule a
793 * callback method which will carry actual result
795 g_idle_add(__bt_adapter_all_properties_cb, (gpointer)result);
798 return BT_STATUS_SUCCESS;
801 int _bt_hal_dbus_get_adapter_properties(void)
805 return __bt_hal_dbus_get_all_adapter_properties();
808 int _bt_hal_get_adapter_powered_state(uint8_t *state)
810 char *adapter_path = NULL;
811 gboolean powered = FALSE;
812 int ret = BT_STATUS_FAIL;
814 /* Check Valid Adapter Path, followed by Adapter Powered state.
815 If any of these fails, adapter will be considered Disabled */
816 adapter_path = _bt_hal_get_adapter_path();
818 if (adapter_path == NULL) {
819 INFO("Adapter is not powered");
820 g_free(adapter_path);
825 /* Check Adapter Powered Status */
826 ret = _bt_hal_is_adapter_powered(&powered);
827 if (BT_STATUS_FAIL == ret) {
828 INFO("Adapter is not powered");
829 g_free(adapter_path);
842 /* Get Discoverable timeout API and callback */
843 static gboolean __bt_adapter_discovery_timeout_cb(gpointer user_data)
845 /* Buffer and propety count management */
846 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
847 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
849 unsigned int *timeout = user_data;
851 memset(buf, 0, sizeof(buf));
854 ev->status = BT_STATUS_SUCCESS;
856 DBG("Discovery timeout in callback: [%d]", *timeout);
858 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_DISC_TIMEOUT,
859 sizeof(unsigned int), timeout);
862 DBG("Timeout value [%d] property Num [%d]", *timeout, ev->num_props);
865 event_cb = _bt_get_adapter_event_cb();
867 ERR("event_cb is NULL");
872 DBG("Send Adapter Properties changed event to HAL user,"
873 " Num Prop [%d] total size [%zd]", ev->num_props, size);
874 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
881 int _bt_hal_dbus_get_discovery_timeout(void)
886 GError *error = NULL;
887 unsigned int *timeout;
890 proxy = _bt_hal_get_adapter_properties_proxy();
892 DBG("Adapter Properties proxy get failed!!!");
893 return BT_STATUS_FAIL;
896 result = g_dbus_proxy_call_sync(proxy,
898 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
899 "DiscoverableTimeout"),
900 G_DBUS_CALL_FLAGS_NONE,
907 ERR("Failed to get local version (Error: %s)", error->message);
908 g_clear_error(&error);
910 ERR("Failed to get local version");
911 return BT_STATUS_FAIL;
914 timeout = g_malloc0(sizeof(int));
916 ERR("Memory allocation failed");
917 g_variant_unref(result);
918 return BT_STATUS_FAIL;
921 g_variant_get(result, "(v)", &temp);
922 *timeout = g_variant_get_uint32(temp);
923 DBG("Timeout value: [%d]", *timeout);
925 g_variant_unref(result);
926 g_variant_unref(temp);
929 * As we need to provide async callback to user from HAL, simply schedule a
930 * callback method which will carry actual result
932 g_idle_add(__bt_adapter_discovery_timeout_cb, (gpointer) timeout);
935 return BT_STATUS_SUCCESS;
938 int _bt_hal_dbus_get_adapter_class(unsigned int *adapter_class)
943 GError *error = NULL;
946 proxy = _bt_hal_get_adapter_properties_proxy();
948 DBG("Adapter Properties proxy get failed!!!");
949 return BT_STATUS_FAIL;
952 result = g_dbus_proxy_call_sync(proxy,
954 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
956 G_DBUS_CALL_FLAGS_NONE,
963 ERR("Failed to get class (Error: %s)", error->message);
964 g_clear_error(&error);
966 ERR("Failed to get class");
967 return BT_STATUS_FAIL;
971 g_variant_get(result, "(v)", &temp);
972 *adapter_class = g_variant_get_uint32(temp);
973 DBG("Class value: [0x%06x]", *adapter_class);
975 g_variant_unref(result);
976 g_variant_unref(temp);
979 return BT_STATUS_SUCCESS;
982 /* Get Discoverable Mode API and callback */
983 static gboolean __bt_adapter_scan_mode_cb(gpointer user_data)
985 /* Buffer and propety count management */
986 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
987 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
989 int *mode = user_data;
991 memset(buf, 0, sizeof(buf));
994 ev->status = BT_STATUS_SUCCESS;
996 DBG("Scan mode callback: [%d]", *mode);
998 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_SCAN_MODE,
1002 DBG("Scan mode [%d] property Num [%d]", *mode, ev->num_props);
1005 event_cb = _bt_get_adapter_event_cb();
1007 ERR("event_cb is NULL");
1012 DBG("Send Adapter Properties changed event to HAL user,"
1013 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1014 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1021 int _bt_hal_dbus_get_scan_mode(void)
1024 gboolean discoverable;
1025 gboolean connectable;
1028 GError *error = NULL;
1033 proxy = _bt_hal_get_adapter_properties_proxy();
1035 DBG("Adapter Properties proxy get failed!!!");
1036 return BT_STATUS_FAIL;
1039 result = g_dbus_proxy_call_sync(proxy,
1041 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1043 G_DBUS_CALL_FLAGS_NONE,
1049 if (error != NULL) {
1050 ERR("Failed to get discoverable mode (Error: %s)", error->message);
1051 g_clear_error(&error);
1053 ERR("Failed to get discoverable mode");
1054 return BT_STATUS_FAIL;
1057 g_variant_get(result, "(v)", &temp);
1058 discoverable = g_variant_get_boolean(temp);
1059 DBG("discoverable:%d", discoverable);
1061 g_variant_unref(result);
1062 g_variant_unref(temp);
1064 if (!discoverable) {
1065 result = g_dbus_proxy_call_sync(proxy,
1067 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1069 G_DBUS_CALL_FLAGS_NONE,
1074 if (error != NULL) {
1075 ERR("Failed to get connectable mode (Error: %s)", error->message);
1076 g_clear_error(&error);
1078 ERR("Failed to get connectable mode");
1079 return BT_STATUS_FAIL;
1082 g_variant_get(result, "(v)", &temp);
1083 connectable = g_variant_get_boolean(temp);
1084 DBG("connectable:%d", connectable);
1086 g_variant_unref(result);
1087 g_variant_unref(temp);
1090 scan_mode = g_malloc0(sizeof(int));
1092 ERR("Memory allocation failed");
1093 return BT_STATUS_FAIL;
1097 *scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
1098 else if (connectable)
1099 *scan_mode = BT_SCAN_MODE_CONNECTABLE;
1101 *scan_mode = BT_SCAN_MODE_NONE;
1104 * As we need to provide async callback to user from HAL, simply schedule a
1105 * callback method which will carry actual result
1107 g_idle_add(__bt_adapter_scan_mode_cb, (gpointer) scan_mode);
1110 return BT_STATUS_SUCCESS;
1113 /* Get Local Version API and callback */
1114 static gboolean __bt_adapter_local_version_cb(gpointer user_data)
1116 /* Buffer and propety count management */
1117 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1118 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1120 char *version = NULL;
1122 memset(buf, 0, sizeof(buf));
1125 ev->status = BT_STATUS_SUCCESS;
1127 version = (char*) user_data;
1128 DBG("Local Version in callback: [%s]", version);
1130 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_VERSION,
1131 (strlen(version) + 1), version);
1134 DBG("Device version [%s] property Num [%d]", version, ev->num_props);
1137 event_cb = _bt_get_adapter_event_cb();
1139 ERR("event_cb is NULL");
1144 DBG("Send Adapter Properties changed event to HAL user,"
1145 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1146 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1153 int _bt_hal_dbus_get_local_version(void)
1156 const char *version = NULL;
1159 GError *error = NULL;
1162 proxy = _bt_hal_get_adapter_properties_proxy();
1164 DBG("Adapter Properties proxy get failed!!!");
1165 return BT_STATUS_FAIL;
1168 result = g_dbus_proxy_call_sync(proxy,
1170 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1172 G_DBUS_CALL_FLAGS_NONE,
1178 if (error != NULL) {
1179 ERR("Failed to get local version (Error: %s)", error->message);
1180 g_clear_error(&error);
1182 ERR("Failed to get local version");
1183 return BT_STATUS_FAIL;
1186 g_variant_get(result, "(v)", &temp);
1187 version = g_variant_dup_string(temp, NULL);
1188 DBG("Local Version: [%s]", version);
1190 g_variant_unref(result);
1191 g_variant_unref(temp);
1194 * As we need to provide async callback to user from HAL, simply schedule a
1195 * callback method which will carry actual result
1197 g_idle_add(__bt_adapter_local_version_cb, (gpointer) version);
1200 return BT_STATUS_SUCCESS;
1203 /* Get Local Name API and callback */
1204 static gboolean __bt_adapter_local_name_cb(gpointer user_data)
1206 /* Buffer and propety count management */
1207 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1208 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1212 memset(buf, 0, sizeof(buf));
1215 ev->status = BT_STATUS_SUCCESS;
1217 name = (char*) user_data;
1218 DBG("Local Name in callback: [%s]", name);
1220 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_NAME,
1221 strlen(name) + 1, name);
1224 DBG("Device name [%s] property Num [%d]", name, ev->num_props);
1227 event_cb = _bt_get_adapter_event_cb();
1229 ERR("event_cb is NULL");
1234 DBG("Send Adapter Properties changed event to HAL user,"
1235 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1236 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1243 int _bt_hal_dbus_get_local_name(void)
1246 const char *name = NULL;
1249 GError *error = NULL;
1252 proxy = _bt_hal_get_adapter_properties_proxy();
1254 DBG("_bt_hal_dbus_get_local_name: Adapter Properties proxy get failed!!!");
1255 return BT_STATUS_FAIL;
1258 result = g_dbus_proxy_call_sync(proxy,
1260 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1262 G_DBUS_CALL_FLAGS_NONE,
1268 if (error != NULL) {
1269 ERR("Failed to get local name (Error: %s)", error->message);
1270 g_clear_error(&error);
1272 ERR("Failed to get local name");
1273 return BT_STATUS_FAIL;
1276 g_variant_get(result, "(v)", &temp);
1277 name = g_variant_dup_string(temp, NULL);
1278 DBG("Local Name: [%s]", name);
1280 g_variant_unref(result);
1281 g_variant_unref(temp);
1284 * As we need to provide async callback to user from HAL, simply schedule a
1285 * callback method which will carry actual result
1287 g_idle_add(__bt_adapter_local_name_cb, (gpointer) name);
1290 return BT_STATUS_SUCCESS;
1293 /* Get Local Address API and callback */
1294 static gboolean __bt_adapter_local_address_cb(gpointer user_data)
1296 /* Buffer and propety count management */
1297 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1298 struct hal_ev_adapter_props_changed *ev = (void*) buf;
1300 char * address = NULL;
1302 memset(buf, 0, sizeof(buf));
1305 ev->status = BT_STATUS_SUCCESS;
1307 address = (char*) user_data;
1310 _bt_hal_convert_addr_string_to_type(bdaddr, address);
1312 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
1313 sizeof(bdaddr), bdaddr);
1316 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
1318 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_ADDR,
1319 sizeof(bdaddr), bdaddr);
1322 event_cb = _bt_get_adapter_event_cb();
1324 ERR("event_cb is NULL");
1329 DBG("Send Device found event to HAL user,"
1330 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1331 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1338 int _bt_hal_dbus_get_local_address(void)
1341 GError *error = NULL;
1342 const char *address;
1348 proxy = _bt_hal_get_adapter_properties_proxy();
1350 DBG("_bt_hal_dbus_get_local_address: Adapter Properties proxy get failed!!!");
1351 return BT_STATUS_FAIL;
1354 result = g_dbus_proxy_call_sync(proxy,
1356 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1358 G_DBUS_CALL_FLAGS_NONE,
1364 ERR("Failed to get local address");
1365 if (error != NULL) {
1366 ERR("Failed to get local address (Error: %s)", error->message);
1367 g_clear_error(&error);
1369 return BT_STATUS_FAIL;
1372 g_variant_get(result, "(v)", &temp);
1373 address = g_variant_dup_string(temp, NULL);
1376 DBG("Address:%s", address);
1378 return BT_STATUS_FAIL;
1380 g_variant_unref(result);
1381 g_variant_unref(temp);
1384 * As we need to provide async callback to user from HAL, simply schedule a
1385 * callback method which will carry actual result
1387 g_idle_add(__bt_adapter_local_address_cb, (gpointer) address);
1390 return BT_STATUS_SUCCESS;
1393 /* Get Local services API and callback */
1394 static gboolean __bt_adapter_service_uuids_cb(gpointer user_data)
1396 GVariant *result = user_data;
1398 GVariantIter *iter = NULL;
1401 /* Buffer and propety count management */
1402 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1403 struct hal_ev_adapter_props_changed *ev = (void*) buf;
1406 /* UUID collection */
1407 uint8_t uuids[HAL_UUID_LEN * MAX_UUID_COUNT];
1410 memset(buf, 0, sizeof(buf));
1413 ev->status = BT_STATUS_SUCCESS;
1415 g_variant_get(result, "(v)", &temp);
1416 g_variant_get(temp, "as", &iter);
1418 ERR("Failed to get UUIDs");
1422 while (g_variant_iter_loop(iter, "s", &uuid_str)) {
1423 uint8_t uuid[HAL_UUID_LEN];
1425 DBG("UUID string [%s]\n", uuid_str);
1426 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
1427 memcpy(uuids + uuid_count * HAL_UUID_LEN, uuid, HAL_UUID_LEN);
1431 size += __bt_insert_hal_properties(buf + size,
1432 HAL_PROP_ADAPTER_UUIDS,
1433 (HAL_UUID_LEN * uuid_count),
1438 event_cb = _bt_get_adapter_event_cb();
1440 ERR("event_cb is NULL");
1445 DBG("Send Adapter properties changed event to HAL user,"
1446 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1447 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1450 g_variant_iter_free(iter);
1451 g_variant_unref(result);
1452 g_variant_unref(temp);
1456 event_cb = _bt_get_adapter_event_cb();
1458 ev->status = BT_STATUS_FAIL;
1460 DBG("Send Adapter properties changed event to HAL user,"
1461 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1462 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1465 g_variant_unref(result);
1469 int _bt_hal_dbus_get_adapter_supported_uuids(void)
1472 GError *error = NULL;
1477 proxy = _bt_hal_get_adapter_properties_proxy();
1480 DBG("_bt_hal_dbus_get_local_name: Adapter Properties proxy get failed!!!");
1481 return BT_STATUS_FAIL;
1484 result = g_dbus_proxy_call_sync(proxy,
1486 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1488 G_DBUS_CALL_FLAGS_NONE,
1494 if (error != NULL) {
1495 ERR("Failed to get UUIDs (Error: %s)", error->message);
1496 g_clear_error(&error);
1498 ERR("Failed to get UUIDs");
1499 return BT_STATUS_FAIL;
1503 DBG("Got All Adaptr service UUID's from Bluez Stack!!, time to start parsing");
1506 * As we need to provide async callback to user from HAL, simply schedule a
1507 * callback method which will carry actual result
1509 g_idle_add(__bt_adapter_service_uuids_cb, (gpointer)result);
1512 return BT_STATUS_SUCCESS;
1515 static gboolean __is_device_paired(GVariantIter *item_iter)
1517 gboolean paired = FALSE;
1521 while (g_variant_iter_loop(item_iter, "{sv}", &key, &value)) {
1522 if (NULL == key || g_strcmp0(key, "Paired"))
1525 paired = g_variant_get_boolean(value);
1526 g_variant_unref(value);
1534 static gboolean __bt_adapter_bonded_devices_cb(gpointer user_data)
1536 /* Buffer and propety count management */
1537 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1538 uint8_t addresses[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1539 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1543 GVariant *result = user_data;
1545 GVariantIter *interface_iter;
1546 GVariantIter *svc_iter;
1547 char *object_path = NULL;
1548 char *interface_str = NULL;
1550 char device_address[BT_HAL_ADDRESS_STRING_SIZE];
1551 uint8_t bdaddr[BT_HAL_ADDRESS_LENGTH_MAX];
1553 memset(buf, 0, sizeof(buf));
1556 ev->status = BT_STATUS_SUCCESS;
1558 INFO("Size [%zd]", size);
1560 /* signature of GetManagedObjects: a{oa{sa{sv}}} */
1561 g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
1563 /* Parse the signature: {oa{sa{sv}}} */
1564 while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
1565 if (object_path == NULL)
1568 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
1569 &interface_str, &svc_iter)) {
1570 if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
1571 DBG("Found a device: %s", object_path);
1572 if (__is_device_paired(svc_iter)) {
1573 _bt_hal_convert_device_path_to_address(object_path, device_address);
1574 DBG("Paired Device Address: [%s]", device_address);
1576 _bt_hal_convert_addr_string_to_type(bdaddr, device_address);
1577 memcpy((addresses + (count * BT_HAL_ADDRESS_LENGTH_MAX)),
1578 bdaddr, BT_HAL_ADDRESS_LENGTH_MAX);
1581 g_variant_iter_free(svc_iter);
1582 g_free(interface_str);
1583 interface_str = NULL;
1589 g_variant_iter_free(iter);
1590 g_variant_unref(result);
1592 size += __bt_insert_hal_properties((buf + size),
1593 HAL_PROP_ADAPTER_BONDED_DEVICES,
1594 (count * BT_HAL_ADDRESS_LENGTH_MAX), addresses);
1598 event_cb = _bt_get_adapter_event_cb();
1600 ERR("event_cb is NULL");
1605 DBG("Send Adapter properties changed event to HAL user,"
1606 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1607 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1613 int _bt_hal_dbus_get_bonded_devices(void)
1615 GDBusProxy *manager_proxy;
1616 GVariant *result = NULL;
1620 manager_proxy = _bt_hal_get_manager_proxy();
1621 if (manager_proxy == NULL)
1622 return BT_STATUS_FAIL;
1624 result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
1626 G_DBUS_CALL_FLAGS_NONE,
1631 ERR("Can't get managed objects");
1632 return BT_STATUS_FAIL;
1636 * As we need to provide async callback to user from HAL, simply schedule a
1637 * callback method which will carry actual result
1639 g_idle_add(__bt_adapter_bonded_devices_cb, (gpointer) result);
1642 return BT_STATUS_SUCCESS;
1645 int _bt_hal_dbus_get_adapter_property(bt_property_type_t property_type)
1649 INFO("property_type: %d", property_type);
1651 switch (property_type) {
1652 case BT_PROPERTY_BDADDR:
1653 return _bt_hal_dbus_get_local_address();
1654 case BT_PROPERTY_BDNAME:
1655 return _bt_hal_dbus_get_local_name();
1656 case BT_PROPERTY_VERSION:
1657 return _bt_hal_dbus_get_local_version();
1658 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
1659 return _bt_hal_dbus_get_discovery_timeout();
1660 case BT_PROPERTY_ADAPTER_SCAN_MODE:
1661 return _bt_hal_dbus_get_scan_mode();
1662 case BT_PROPERTY_CLASS_OF_DEVICE:
1663 return BT_STATUS_UNSUPPORTED;
1664 case BT_PROPERTY_UUIDS:
1665 return _bt_hal_dbus_get_adapter_supported_uuids();
1666 case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
1667 return _bt_hal_dbus_get_bonded_devices();
1669 return BT_STATUS_UNSUPPORTED;
1675 static int __bt_hal_dbus_set_local_name(void *data)
1678 const char *name = data;
1680 GError *error = NULL;
1683 DBG("Local Name: [%s]", name);
1684 proxy = _bt_hal_get_adapter_properties_proxy();
1686 DBG("_bt_hal_dbus_get_local_name: Adapter Properties proxy get failed!!!");
1687 return BT_STATUS_FAIL;
1690 result = g_dbus_proxy_call_sync(proxy,
1692 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE,
1693 "Alias", g_variant_new("s", name)),
1694 G_DBUS_CALL_FLAGS_NONE,
1699 if (error != NULL) {
1700 ERR("Failed to set local name (Error: %s)", error->message);
1701 g_clear_error(&error);
1703 ERR("Failed to set local name");
1704 return BT_STATUS_FAIL;
1706 g_variant_unref(result);
1709 return BT_STATUS_SUCCESS;
1712 static int __bt_hal_dbus_set_scan_mode(void *data)
1717 GError *error = NULL;
1722 DBG("Scan mode: [%d]", *mode);
1723 proxy = _bt_hal_get_adapter_properties_proxy();
1725 DBG("Adapter Properties proxy get failed!!!");
1726 return BT_STATUS_FAIL;
1730 case BT_SCAN_MODE_NONE:
1734 case BT_SCAN_MODE_CONNECTABLE:
1738 case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
1743 ERR("Invalid scan mode");
1744 return BT_STATUS_FAIL;
1747 result = g_dbus_proxy_call_sync(proxy,
1749 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE,
1750 "Connectable", g_variant_new("b", pg_scan)),
1751 G_DBUS_CALL_FLAGS_NONE,
1756 if (error != NULL) {
1757 ERR("Failed to set connectable property (Error: %s)", error->message);
1758 g_clear_error(&error);
1760 ERR("Failed to set connectable property");
1761 return BT_STATUS_FAIL;
1763 g_variant_unref(result);
1765 result = g_dbus_proxy_call_sync(proxy,
1767 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE, "Discoverable",
1768 g_variant_new("b", inq_scan)),
1769 G_DBUS_CALL_FLAGS_NONE,
1774 if (error != NULL) {
1775 ERR("Failed to set Discoverable property (Error: %s)", error->message);
1776 g_clear_error(&error);
1778 ERR("Failed to set Discoverable property");
1779 return BT_STATUS_FAIL;
1781 g_variant_unref(result);
1784 return BT_STATUS_SUCCESS;
1787 static int __bt_hal_dbus_set_discovery_timeout(void *data)
1790 unsigned int *timeout = data;
1792 GError *error = NULL;
1797 DBG("Discovery Timeout: [%d]", *timeout);
1798 proxy = _bt_hal_get_adapter_properties_proxy();
1800 DBG("Adapter Properties proxy get failed!!!");
1801 return BT_STATUS_FAIL;
1804 result = g_dbus_proxy_call_sync(proxy,
1806 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE,
1807 "DiscoverableTimeout", g_variant_new("u", *timeout)),
1808 G_DBUS_CALL_FLAGS_NONE,
1813 if (error != NULL) {
1814 ERR("Failed to set DiscoverableTimeout property (Error: %s)", error->message);
1815 g_clear_error(&error);
1817 ERR("Failed to set DiscoverableTimeout property");
1818 return BT_STATUS_FAIL;
1820 g_variant_unref(result);
1823 return BT_STATUS_SUCCESS;
1826 /* Set Adapter Properties */
1827 int _bt_hal_dbus_set_adapter_property(const bt_property_t *property)
1833 if (property == NULL || property->val == NULL) {
1834 ERR("Invalid parameters received");
1835 return BT_STATUS_FAIL;
1838 switch (property->type) {
1839 case BT_PROPERTY_BDNAME:
1840 result = __bt_hal_dbus_set_local_name(property->val);
1842 case BT_PROPERTY_ADAPTER_SCAN_MODE:
1843 result = __bt_hal_dbus_set_scan_mode(property->val);
1845 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
1846 result = __bt_hal_dbus_set_discovery_timeout(property->val);
1849 result = BT_STATUS_UNSUPPORTED;
1852 DBG("Result= [%d]", result);