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)
61 if (system_conn == NULL)
62 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
67 GDBusProxy *_bt_init_core_proxy(void)
69 GDBusConnection *conn;
71 conn = __bt_hal_get_system_gconn();
75 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
90 static GDBusProxy *__bt_get_core_proxy(void)
92 return (core_proxy) ? core_proxy : _bt_init_core_proxy();
95 /* To send stack event to hal-bluetooth handler */
96 void _bt_hal_dbus_store_stack_msg_cb(handle_stack_msg cb)
101 int _bt_hal_enable_core(void)
106 GError *error = NULL;
108 proxy = __bt_get_core_proxy();
110 return BT_HAL_ERROR_INTERNAL;
112 /* Clean up the process */
113 result = g_dbus_proxy_call_sync(proxy,
116 G_DBUS_CALL_FLAGS_NONE,
123 ERR("Bt core call failed(Error: %s)", error->message);
124 g_clear_error(&error);
126 ERR("Bt core call failed");
127 return BT_HAL_ERROR_INTERNAL;
130 g_variant_unref(result);
131 return BT_HAL_ERROR_NONE;
134 static gboolean __bt_hal_send_adapter_event(gpointer user_data)
136 struct hal_ev_adapter_state_changed ev;
137 gboolean *enable = (gboolean *)user_data;
140 ev.state = HAL_POWER_ON;
142 ev.state = HAL_POWER_OFF;
145 event_cb = _bt_get_adapter_event_cb();
148 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
154 static gboolean __bt_hal_send_le_event(gpointer user_data)
156 struct hal_ev_le_state_changed ev;
157 gboolean *enable = (gboolean *)user_data;
160 ev.state = HAL_POWER_ON;
162 ev.state = HAL_POWER_OFF;
165 event_cb = _bt_get_adapter_event_cb();
168 event_cb(HAL_EV_LE_STATE_CHANGED, &ev, sizeof(ev));
175 int _bt_hal_dbus_enable_adapter(void)
178 GError *error = NULL;
179 GVariant *result = NULL;
180 unsigned char powered = 0;
184 int le_value = VCONFKEY_BT_LE_STATUS_OFF;
185 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &le_value))
186 ERR("fail to get vconf key!");
188 if (_bt_hal_get_adapter_powered_state(&powered) == BT_STATUS_FAIL)
189 ERR("_bt_hal_get_adapter_powered_state failed");
191 /*if LE is enabled and bluez is UP , send event from here and return.*/
192 if ((le_value == VCONFKEY_BT_LE_STATUS_ON) && (powered == 1)) {
193 gboolean *user_data = g_new0(int, 1);
195 g_idle_add(__bt_hal_send_adapter_event, (gpointer)user_data);
196 return BT_STATUS_SUCCESS;
199 if (TIZEN_FEATURE_BT_USB_DONGLE && powered == 1) {
200 gboolean *user_data = g_new0(int, 1);
202 g_idle_add(__bt_hal_send_adapter_event, (gpointer)user_data);
203 return BT_STATUS_SUCCESS;
206 proxy = __bt_get_core_proxy();
209 ERR("_bt_hal_dbus_enable_adapter: Core proxy get failed!!!");
210 return BT_STATUS_FAIL;
213 _bt_hal_set_adapter_request_state(TRUE);
214 _bt_hal_set_le_request_state(TRUE);
215 result = g_dbus_proxy_call_sync(proxy, "EnableAdapter",
217 G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
220 ERR("EnableAdapter failed: %s", error->message);
221 g_clear_error(&error);
223 _bt_hal_set_adapter_request_state(FALSE);
224 _bt_hal_set_le_request_state(FALSE);
225 result = g_dbus_proxy_call_sync(proxy,
228 G_DBUS_CALL_FLAGS_NONE,
234 ERR("Bt core call failed(Error: %s)", error->message);
235 g_clear_error(&error);
237 g_variant_unref(result);
239 /* TODO: Terminate bluetooth service or not, need to check */
240 /*g_idle_add((GSourceFunc)_bt_terminate_service, NULL);*/
241 return BT_STATUS_FAIL;
244 g_variant_unref(result);
245 return BT_STATUS_SUCCESS;
248 int _bt_hal_dbus_disable_adapter(void)
251 GError *error = NULL;
252 GVariant *result = NULL;
255 proxy = __bt_get_core_proxy();
257 ERR("_bt_hal_dbus_enable_adapter: Core proxy get failed!!!");
258 return BT_STATUS_FAIL;
261 result = g_dbus_proxy_call_sync(proxy, "DisableAdapter",
263 G_DBUS_CALL_FLAGS_NONE, -1,
266 ERR("DisableAdapter failed: %s", error->message);
267 g_clear_error(&error);
269 g_variant_unref(result);
271 /* TODO: Terminate bluetooth service or not, need to check */
272 /*g_idle_add((GSourceFunc)_bt_terminate_service, NULL);*/
273 return BT_STATUS_FAIL;
276 g_variant_unref(result);
277 return BT_STATUS_SUCCESS;
280 int _bt_hal_dbus_recover_adapter(void)
283 GVariant *result = NULL;
284 GError *error = NULL;
287 proxy = __bt_get_core_proxy();
289 ERR("_bt_hal_dbus_recover_adapter: Core proxy get failed!!!");
290 return BT_STATUS_FAIL;
293 result = g_dbus_proxy_call_sync(proxy, "RecoverAdapter",
295 G_DBUS_CALL_FLAGS_NONE, -1,
298 ERR("RecoverAdapter failed: %s", error->message);
299 g_clear_error(&error);
301 return BT_STATUS_FAIL;
304 g_variant_unref(result);
305 return BT_STATUS_SUCCESS;
309 int _bt_hal_dbus_enable_le(void)
312 GError *error = NULL;
313 GVariant *result = NULL;
314 int adapter_value = VCONFKEY_BT_STATUS_OFF;
315 unsigned char powered = 0;
319 if (vconf_get_int(VCONFKEY_BT_STATUS, &adapter_value) != 0)
320 ERR("fail to get vconf key!");
322 if (_bt_hal_get_adapter_powered_state(&powered) == BT_STATUS_FAIL)
323 ERR("_bt_hal_get_adapter_powered_state failed");
325 if ((adapter_value == VCONFKEY_BT_STATUS_ON) && (powered == 1)) {
326 gboolean *user_data = g_new0(int, 1);
328 g_idle_add(__bt_hal_send_le_event, (gpointer)user_data);
329 return BT_STATUS_SUCCESS;
332 proxy = __bt_get_core_proxy();
335 DBG("_bt_hal_dbus_enable_le: Core proxy get failed!!!");
336 return BT_STATUS_FAIL;
338 _bt_hal_set_le_request_state(TRUE);
340 result = g_dbus_proxy_call_sync(proxy, "EnableAdapterLe",
342 G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
345 DBG("EnableAdapterLe failed: %s", error->message);
346 g_clear_error(&error);
348 result = g_dbus_proxy_call_sync(proxy,
351 G_DBUS_CALL_FLAGS_NONE,
356 _bt_hal_set_le_request_state(FALSE);
358 DBG("Bt core call failed(Error: %s)", error->message);
359 g_clear_error(&error);
361 g_variant_unref(result);
363 return BT_STATUS_FAIL;
367 g_variant_unref(result);
368 return BT_STATUS_SUCCESS;
371 int _bt_hal_dbus_disable_le(void)
374 GError *error = NULL;
375 GVariant *result = NULL;
376 int adapter_value = VCONFKEY_BT_STATUS_OFF;
379 if (vconf_get_int(VCONFKEY_BT_STATUS, &adapter_value) != 0)
380 ERR("fail to get vconf key!");
382 if (adapter_value == VCONFKEY_BT_STATUS_ON) {
383 gboolean *user_data = g_new0(int, 1);
385 g_idle_add(__bt_hal_send_le_event, (gpointer)user_data);
386 return BT_STATUS_SUCCESS;
389 proxy = __bt_get_core_proxy();
392 DBG("_bt_hal_dbus_disable_le: Core proxy get failed!!!");
393 return BT_STATUS_FAIL;
396 result = g_dbus_proxy_call_sync(proxy, "DisableAdapterLe",
398 G_DBUS_CALL_FLAGS_NONE, -1,
401 DBG("DisableAdapter failed: %s", error->message);
402 g_clear_error(&error);
404 g_variant_unref(result);
405 return BT_STATUS_FAIL;
411 g_variant_unref(result);
412 return BT_STATUS_SUCCESS;
417 int _bt_hal_dbus_reset_adapter(void)
421 GError *error = NULL;
424 proxy = __bt_get_core_proxy();
426 return BT_STATUS_FAIL;
428 result = g_dbus_proxy_call_sync(proxy,
431 G_DBUS_CALL_FLAGS_NONE,
438 ERR("Failed to ResetAdapter (Error: %s)", error->message);
439 g_clear_error(&error);
441 ERR("Failed to ResetAdapter");
442 return BT_STATUS_FAIL;
445 g_variant_unref(result);
446 return BT_STATUS_SUCCESS;
450 int _bt_hal_dbus_start_discovery(gboolean is_custom,
451 bt_disc_role_type_t role)
454 GError *error = NULL;
456 const gchar *disc_type;
457 DBG("Discovery Type: Is Custom : [%s]", is_custom ? "TRUE" : "FALSE");
459 proxy = _bt_hal_get_adapter_proxy();
461 DBG("Adapter proxy get failed!!!");
462 return BT_STATUS_FAIL;
466 if (role == BT_DISC_ROLE_BREDR)
468 else if (role == BT_DISC_ROLE_LE)
470 else if (role == BT_DISC_ROLE_DUAL)
471 disc_type = "LE_BREDR";
473 return BT_STATUS_PARM_INVALID;
475 result = g_dbus_proxy_call_sync(proxy,
476 "StartCustomDiscovery",
477 g_variant_new("s", disc_type),
478 G_DBUS_CALL_FLAGS_NONE,
483 result = g_dbus_proxy_call_sync(proxy,
486 G_DBUS_CALL_FLAGS_NONE,
493 ERR("StartDiscovery failed (Error: %s)", error->message);
494 g_clear_error(&error);
496 ERR("StartDiscovery failed");
497 return BT_STATUS_FAIL;
500 /* discovery status will be change in event */
502 g_variant_unref(result);
503 return BT_STATUS_SUCCESS;
506 int _bt_hal_dbus_stop_discovery(void)
509 GError *error = NULL;
511 struct hal_ev_discovery_state_changed ev;
514 memset(&ev, 0, sizeof(ev));
516 proxy = _bt_hal_get_adapter_proxy();
518 DBG("_bt_hal_dbus_stop_discovery: Adapter proxy get failed!!!");
519 return BT_STATUS_FAIL;
522 result = g_dbus_proxy_call_sync(proxy,
525 G_DBUS_CALL_FLAGS_NONE,
532 ERR("StopDiscovery failed (Error: %s)", error->message);
533 g_clear_error(&error);
535 ERR("StopDiscovery failed");
536 return BT_STATUS_FAIL;
540 ev.state = HAL_DISCOVERY_STATE_STOPPED;
543 event_cb = _bt_hal_get_stack_message_handler();
545 DBG("Sending HAL_EV_DISCOVERY_STATE_CHANGED event");
546 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, (void*)&ev, sizeof(ev));
549 /* discovery status will be change in event */
551 g_variant_unref(result);
552 return BT_STATUS_SUCCESS;
555 int _bt_hal_dbus_get_energy_info(uint32_t *tx_time, uint32_t *rx_time,
556 uint32_t *idle_time, uint32_t *energy_used)
559 GError *error = NULL;
562 if (!tx_time || !rx_time || !idle_time || !energy_used) {
563 ERR("Invalid parameter");
564 return BT_STATUS_FAIL;
567 proxy = _bt_hal_get_adapter_proxy();
569 DBG("_bt_hal_dbus_get_energy_info: Adapter proxy get failed!!!");
570 return BT_STATUS_FAIL;
573 result = g_dbus_proxy_call_sync(proxy,
576 G_DBUS_CALL_FLAGS_NONE,
583 ERR("GetEnergyInfo failed (Error: %s)", error->message);
584 g_clear_error(&error);
586 ERR("GetEnergyInfo failed");
588 return BT_STATUS_FAIL;
591 g_variant_get(result, "(uuuu)", tx_time, rx_time, idle_time, energy_used);
593 DBG("Tx time: %d, Rx time: %d, Idle time: %d", *tx_time, *rx_time, *idle_time);
595 g_variant_unref(result);
596 return BT_STATUS_SUCCESS;
599 int _bt_hal_dbus_get_profile_connected_devices(const char *profile_uuid)
601 GDBusConnection *conn;
602 GDBusProxy *manager_proxy;
603 GVariant *result = NULL;
604 GVariant *result1 = NULL;
605 GVariantIter *iter = NULL;
606 GError *error = NULL;
607 char *object_path = NULL;
608 GVariantIter *interface_iter;
609 char *interface_str = NULL;
610 GDBusProxy *device_proxy = NULL;
611 gboolean is_connected = FALSE;
612 struct hal_ev_adapter_profile_connected_devices ev;
614 DBG("Get Profile Connected Devices. UUID: %s", profile_uuid);
615 memset(&ev, 0, sizeof(ev));
617 conn = __bt_hal_get_system_gconn();
619 return BT_STATUS_FAIL;
621 manager_proxy = _bt_hal_get_manager_proxy();
622 if (manager_proxy == NULL)
623 return BT_STATUS_FAIL;
625 result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
627 G_DBUS_CALL_FLAGS_NONE,
634 ERR("GetManagedObjects failed (Error: %s)", error->message);
635 g_clear_error(&error);
638 ERR("GetManagedObjects failed");
639 return BT_STATUS_FAIL;
642 /* signature of GetManagedObjects: a{oa{sa{sv}}} */
643 g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
645 /* Parse the signature: oa{sa{sv}}} */
646 while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
647 if (object_path == NULL)
650 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
651 &interface_str, NULL)) {
652 if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
653 DBG("Found a device: %s", object_path);
654 g_free(interface_str);
656 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
657 NULL, BT_HAL_BLUEZ_NAME,
658 object_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
660 if (device_proxy == NULL) {
661 DBG("Device don't have this service");
665 result1 = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
666 g_variant_new("(s)", profile_uuid),
667 G_DBUS_CALL_FLAGS_NONE,
672 if (result1 == NULL) {
674 ERR("Error occured in Proxy call [%s]", error->message);
678 g_object_unref(device_proxy);
681 g_variant_get(result1, "(b)", &is_connected);
683 if (is_connected == TRUE) {
684 char address[BT_HAL_ADDRESS_STRING_SIZE];
685 _bt_hal_convert_device_path_to_address(object_path, address);
686 DBG("Address: %s", address);
687 if (ev.count >= 10) {
688 INFO("Too many address");
691 _bt_hal_convert_addr_string_to_type(ev.bdaddr_list[ev.count], address);
695 g_variant_unref(result1);
696 g_object_unref(device_proxy);
703 event_cb = _bt_hal_get_stack_message_handler();
705 DBG("Sending HAL_EV_ADAPTER_PROFILE_CONNECTED_DEVICES event");
706 event_cb(HAL_EV_ADAPTER_PROFILE_CONNECTED_DEVICES, (void *)&ev, sizeof(ev));
709 g_variant_unref(result);
710 g_variant_iter_free(iter);
713 return BT_STATUS_SUCCESS;
716 static gboolean __bt_adapter_all_properties_cb(gpointer user_data)
718 GVariant *result = user_data;
719 GVariantIter *property_iter;
723 /* Buffer and propety count management */
724 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
725 struct hal_ev_adapter_props_changed *ev = (void*) buf;
727 gchar *address = NULL;
729 unsigned int cod = 0;
730 gboolean discoverable;
731 gboolean connectable;
732 unsigned int scan_mode = BT_SCAN_MODE_NONE;
733 unsigned int disc_timeout;
735 gboolean is_discovering;
736 gboolean is_le_discovering;
737 uint8_t ipsp_initialized;
740 unsigned int pairable_timeout;
741 gboolean scan_mode_property_update = FALSE;
745 memset(buf, 0, sizeof(buf));
748 ev->status = BT_STATUS_SUCCESS;
750 DBG("@@Start parsing properties");
751 g_variant_get(result, "(a{sv})", &property_iter);
752 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
753 if (!g_strcmp0(key, "Address")) {
756 address = (gchar *) g_variant_get_string(value, NULL);
757 DBG("Address [%s]", address);
758 _bt_hal_convert_addr_string_to_type(bdaddr, address);
759 size += __bt_insert_hal_properties(buf + size,
760 HAL_PROP_ADAPTER_ADDR, sizeof(bdaddr), bdaddr);
762 } else if (!g_strcmp0(key, "Alias")) {
763 name = (gchar *) g_variant_get_string(value, NULL);
764 DBG("Alias [%s]", name);
765 size += __bt_insert_hal_properties(buf + size,
766 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
768 } else if (!g_strcmp0(key, "Class")) {
769 cod = g_variant_get_uint32(value);
770 DBG("Class [%d]", cod);
771 size += __bt_insert_hal_properties(buf + size,
772 HAL_PROP_ADAPTER_CLASS, sizeof(unsigned int), &cod);
774 } else if (!g_strcmp0(key, "Discoverable")) {
775 discoverable = g_variant_get_boolean(value);
776 DBG("Discoverable [%d]", discoverable);
778 scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
779 scan_mode_property_update = TRUE;
780 } else if (!g_strcmp0(key, "DiscoverableTimeout")) {
781 disc_timeout = g_variant_get_uint32(value);
782 DBG("Discoverable Timeout [%d]", disc_timeout);
783 size += __bt_insert_hal_properties(buf + size,
784 HAL_PROP_ADAPTER_DISC_TIMEOUT, sizeof(unsigned int), &disc_timeout);
786 } else if (!g_strcmp0(key, "Connectable")) {
787 connectable = g_variant_get_boolean(value);
788 DBG("Connectable [%d]", connectable);
789 if (scan_mode == BT_SCAN_MODE_NONE)
790 scan_mode = BT_SCAN_MODE_CONNECTABLE;
791 scan_mode_property_update = TRUE;
792 } else if (!g_strcmp0(key, "Version")) {
793 version = (gchar *) g_variant_get_string(value, NULL);
794 DBG("Version [%s]", version);
795 size += __bt_insert_hal_properties(buf + size,
796 HAL_PROP_ADAPTER_VERSION, strlen(version) + 1, version);
798 } else if (!g_strcmp0(key, "Name")) {
799 name = (gchar *) g_variant_get_string(value, NULL);
800 DBG("Name [%s]", name);
801 size += __bt_insert_hal_properties(buf + size,
802 HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
804 } else if (!g_strcmp0(key, "Powered")) {
805 powered = g_variant_get_boolean(value);
806 DBG("Powered = [%d]", powered);
807 } else if (!g_strcmp0(key, "Pairable")) {
808 pairable = (g_variant_get_boolean(value) ? 1 : 0);
809 DBG("Pairable [%d]", pairable);
810 size += __bt_insert_hal_properties(buf + size,
811 HAL_PROP_ADAPTER_PAIRABLE, sizeof(uint8_t), &pairable);
813 } else if (!g_strcmp0(key, "PairableTimeout")) {
814 pairable_timeout = g_variant_get_uint32(value);
815 DBG("Pairable Timeout = [%d]", pairable_timeout);
816 size += __bt_insert_hal_properties(buf + size,
817 HAL_PROP_ADAPTER_PAIRABLE_TIMEOUT, sizeof(unsigned int), &pairable_timeout);
819 } else if (!g_strcmp0(key, "UUIDs")) {
824 size1 = g_variant_get_size(value);
825 int num_props_tmp = ev->num_props;
827 uuid_value = (char **)g_variant_get_strv(value, &size1);
828 for (i = 0; uuid_value[i] != NULL; i++)
830 /* UUID collection */
831 uint8_t uuids[HAL_UUID_LEN * uuid_count];
832 for (i = 0; uuid_value[i] != NULL; i++) {
833 char *uuid_str = NULL;
834 uint8_t uuid[HAL_UUID_LEN];
835 uuid_str = g_strdup(uuid_value[i]);
836 DBG("UUID string [%s]\n", uuid_str);
837 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
838 memcpy(uuids + i * HAL_UUID_LEN, uuid, HAL_UUID_LEN);
841 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_UUIDS,
842 (HAL_UUID_LEN * uuid_count),
844 ev->num_props = num_props_tmp + 1;
847 } else if (!g_strcmp0(key, "Discovering")) {
848 is_discovering = g_variant_get_boolean(value);
849 DBG("Discovering = [%d]", is_discovering);
850 } else if (!g_strcmp0(key, "LEDiscovering")) {
851 is_le_discovering = g_variant_get_boolean(value);
852 DBG("LE Discovering = [%d]", is_le_discovering);
853 } else if (!g_strcmp0(key, "Modalias")) {
854 char *modalias = NULL;
855 g_variant_get(value, "s", &modalias);
856 DBG("Adapter ModAlias [%s]", modalias);
857 size += __bt_insert_hal_properties(buf + size,
858 HAL_PROP_ADAPTER_MODALIAS, strlen(modalias) + 1, modalias);
861 } else if (!g_strcmp0(key, "SupportedLEFeatures")) {
862 DBG("LE Supported features");
865 GVariantIter *iter = NULL;
866 bt_local_le_features_t le_features;
867 gboolean le_features_present = FALSE;
869 memset(&le_features, 0x00, sizeof(le_features));
871 g_variant_get(value, "as", &iter);
873 while (g_variant_iter_loop(iter, "s", &name)) {
874 DBG("name = %s", name);
875 g_variant_iter_loop(iter, "s", &val);
876 DBG("Value = %s", val);
877 _bt_hal_update_le_feature_support(name, val, &le_features);
878 le_features_present = TRUE;
881 g_variant_iter_free(iter);
883 if (le_features_present) {
884 size += __bt_insert_hal_properties(buf + size,
885 HAL_PROP_ADAPTER_LOCAL_LE_FEAT, sizeof(le_features), &le_features);
888 DBG("le supported features values are NOT provided by Stack");
891 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
892 ipsp_initialized = (g_variant_get_boolean(value) ? 1 : 0);
893 DBG("IPSP Initialized = %d", ipsp_initialized);
894 size += __bt_insert_hal_properties(buf + size,
895 HAL_PROP_ADAPTER_IPSP_INITIALIZED, sizeof(uint8_t), &ipsp_initialized);
898 ERR("Unhandled Property:[%s]", key);
902 if (scan_mode_property_update) {
903 size += __bt_insert_hal_properties(buf + size,
904 HAL_PROP_ADAPTER_SCAN_MODE, sizeof(int), &scan_mode);
909 event_cb = _bt_get_adapter_event_cb();
911 ERR("event_cb is NULL");
916 DBG("Send Adapter properties changed event to HAL user,"
917 " Num Prop [%d] total size [%zd]", ev->num_props, size);
918 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
921 g_variant_unref(result);
922 g_variant_iter_free(property_iter);
926 static int __bt_hal_dbus_get_all_adapter_properties(void)
930 GError *error = NULL;
934 proxy = _bt_hal_get_adapter_properties_proxy();
936 DBG("Adapter Properties proxy get failed!!!");
937 return BT_STATUS_FAIL;
940 result = g_dbus_proxy_call_sync(proxy,
942 g_variant_new("(s)", BT_HAL_ADAPTER_INTERFACE),
943 G_DBUS_CALL_FLAGS_NONE,
950 ERR("Failed to get all adapter properties (Error: %s)", error->message);
951 g_clear_error(&error);
953 ERR("Failed to get all adapter properties");
954 return BT_STATUS_FAIL;
957 DBG("Got All properties from Bluez Stack!!, time to start parsing");
959 * As we need to provide async callback to user from HAL, simply schedule a
960 * callback method which will carry actual result
962 g_idle_add(__bt_adapter_all_properties_cb, (gpointer)result);
965 return BT_STATUS_SUCCESS;
968 int _bt_hal_dbus_get_adapter_properties(void)
972 return __bt_hal_dbus_get_all_adapter_properties();
975 int _bt_hal_get_adapter_powered_state(uint8_t *state)
977 char *adapter_path = NULL;
978 gboolean powered = FALSE;
979 int ret = BT_STATUS_FAIL;
981 /* Check Valid Adapter Path, followed by Adapter Powered state.
982 If any of these fails, adapter will be considered Disabled */
983 adapter_path = _bt_hal_get_adapter_path();
985 if (adapter_path == NULL) {
986 INFO("adapter_path is NULL");
987 g_free(adapter_path);
992 /* Check Adapter Powered Status */
993 ret = _bt_hal_is_adapter_powered(&powered);
994 if (BT_STATUS_FAIL == ret) {
995 INFO("Adapter is not powered");
996 g_free(adapter_path);
1001 g_free(adapter_path);
1011 /* Get Discoverable timeout API and callback */
1012 static gboolean __bt_adapter_discovery_timeout_cb(gpointer user_data)
1014 /* Buffer and propety count management */
1015 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1016 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1018 unsigned int *timeout = user_data;
1020 memset(buf, 0, sizeof(buf));
1023 ev->status = BT_STATUS_SUCCESS;
1025 DBG("Discovery timeout in callback: [%d]", *timeout);
1027 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_DISC_TIMEOUT,
1028 sizeof(unsigned int), timeout);
1031 DBG("Timeout value [%d] property Num [%d]", *timeout, ev->num_props);
1034 event_cb = _bt_get_adapter_event_cb();
1036 ERR("event_cb is NULL");
1041 DBG("Send Adapter Properties changed event to HAL user,"
1042 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1043 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1050 int _bt_hal_dbus_get_discovery_timeout(void)
1055 GError *error = NULL;
1056 unsigned int *timeout;
1059 proxy = _bt_hal_get_adapter_properties_proxy();
1061 DBG("Adapter Properties proxy get failed!!!");
1062 return BT_STATUS_FAIL;
1065 result = g_dbus_proxy_call_sync(proxy,
1067 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1068 "DiscoverableTimeout"),
1069 G_DBUS_CALL_FLAGS_NONE,
1075 if (error != NULL) {
1076 ERR("Failed to get local version (Error: %s)", error->message);
1077 g_clear_error(&error);
1079 ERR("Failed to get local version");
1080 return BT_STATUS_FAIL;
1083 timeout = g_malloc0(sizeof(int));
1085 ERR("Memory allocation failed");
1086 g_variant_unref(result);
1087 return BT_STATUS_FAIL;
1090 g_variant_get(result, "(v)", &temp);
1091 *timeout = g_variant_get_uint32(temp);
1092 DBG("Timeout value: [%d]", *timeout);
1094 g_variant_unref(result);
1095 g_variant_unref(temp);
1098 * As we need to provide async callback to user from HAL, simply schedule a
1099 * callback method which will carry actual result
1101 g_idle_add(__bt_adapter_discovery_timeout_cb, (gpointer) timeout);
1104 return BT_STATUS_SUCCESS;
1107 int _bt_hal_dbus_get_adapter_class(unsigned int *adapter_class)
1112 GError *error = NULL;
1115 proxy = _bt_hal_get_adapter_properties_proxy();
1117 DBG("Adapter Properties proxy get failed!!!");
1118 return BT_STATUS_FAIL;
1121 result = g_dbus_proxy_call_sync(proxy,
1123 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1125 G_DBUS_CALL_FLAGS_NONE,
1131 if (error != NULL) {
1132 ERR("Failed to get class (Error: %s)", error->message);
1133 g_clear_error(&error);
1135 ERR("Failed to get class");
1136 return BT_STATUS_FAIL;
1140 g_variant_get(result, "(v)", &temp);
1141 *adapter_class = g_variant_get_uint32(temp);
1142 DBG("Class value: [0x%06x]", *adapter_class);
1144 g_variant_unref(result);
1145 g_variant_unref(temp);
1148 return BT_STATUS_SUCCESS;
1151 /* Get Discoverable Mode API and callback */
1152 static gboolean __bt_adapter_scan_mode_cb(gpointer user_data)
1154 /* Buffer and propety count management */
1155 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1156 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1158 int *mode = user_data;
1160 memset(buf, 0, sizeof(buf));
1163 ev->status = BT_STATUS_SUCCESS;
1165 DBG("Scan mode callback: [%d]", *mode);
1167 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_SCAN_MODE,
1171 DBG("Scan mode [%d] property Num [%d]", *mode, ev->num_props);
1174 event_cb = _bt_get_adapter_event_cb();
1176 ERR("event_cb is NULL");
1181 DBG("Send Adapter Properties changed event to HAL user,"
1182 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1183 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1190 int _bt_hal_dbus_get_scan_mode(void)
1193 gboolean discoverable = FALSE;
1194 gboolean connectable = FALSE;
1197 GError *error = NULL;
1202 proxy = _bt_hal_get_adapter_properties_proxy();
1204 DBG("Adapter Properties proxy get failed!!!");
1205 return BT_STATUS_FAIL;
1208 result = g_dbus_proxy_call_sync(proxy,
1210 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1212 G_DBUS_CALL_FLAGS_NONE,
1218 if (error != NULL) {
1219 ERR("Failed to get discoverable mode (Error: %s)", error->message);
1220 g_clear_error(&error);
1222 ERR("Failed to get discoverable mode");
1223 return BT_STATUS_FAIL;
1226 g_variant_get(result, "(v)", &temp);
1227 discoverable = g_variant_get_boolean(temp);
1228 DBG("discoverable:%d", discoverable);
1230 g_variant_unref(result);
1231 g_variant_unref(temp);
1233 if (!discoverable) {
1234 result = g_dbus_proxy_call_sync(proxy,
1236 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1238 G_DBUS_CALL_FLAGS_NONE,
1243 if (error != NULL) {
1244 ERR("Failed to get connectable mode (Error: %s)", error->message);
1245 g_clear_error(&error);
1247 ERR("Failed to get connectable mode");
1248 return BT_STATUS_FAIL;
1251 g_variant_get(result, "(v)", &temp);
1252 connectable = g_variant_get_boolean(temp);
1253 DBG("connectable:%d", connectable);
1255 g_variant_unref(result);
1256 g_variant_unref(temp);
1259 scan_mode = g_malloc0(sizeof(int));
1261 ERR("Memory allocation failed");
1262 return BT_STATUS_FAIL;
1266 *scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
1267 else if (connectable)
1268 *scan_mode = BT_SCAN_MODE_CONNECTABLE;
1270 *scan_mode = BT_SCAN_MODE_NONE;
1273 * As we need to provide async callback to user from HAL, simply schedule a
1274 * callback method which will carry actual result
1276 g_idle_add(__bt_adapter_scan_mode_cb, (gpointer) scan_mode);
1279 return BT_STATUS_SUCCESS;
1282 /* Get Local Version API and callback */
1283 static gboolean __bt_adapter_local_version_cb(gpointer user_data)
1285 /* Buffer and propety count management */
1286 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1287 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1289 char *version = NULL;
1291 memset(buf, 0, sizeof(buf));
1294 ev->status = BT_STATUS_SUCCESS;
1296 version = (char*) user_data;
1297 DBG("Local Version in callback: [%s]", version);
1299 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_VERSION,
1300 (strlen(version) + 1), version);
1303 DBG("Device version [%s] property Num [%d]", version, ev->num_props);
1306 event_cb = _bt_get_adapter_event_cb();
1308 ERR("event_cb is NULL");
1313 DBG("Send Adapter Properties changed event to HAL user,"
1314 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1315 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1322 int _bt_hal_dbus_get_local_version(void)
1325 const char *version = NULL;
1328 GError *error = NULL;
1331 proxy = _bt_hal_get_adapter_properties_proxy();
1333 DBG("Adapter Properties proxy get failed!!!");
1334 return BT_STATUS_FAIL;
1337 result = g_dbus_proxy_call_sync(proxy,
1339 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1341 G_DBUS_CALL_FLAGS_NONE,
1347 if (error != NULL) {
1348 ERR("Failed to get local version (Error: %s)", error->message);
1349 g_clear_error(&error);
1351 ERR("Failed to get local version");
1352 return BT_STATUS_FAIL;
1355 g_variant_get(result, "(v)", &temp);
1356 version = g_variant_dup_string(temp, NULL);
1357 DBG("Local Version: [%s]", version);
1359 g_variant_unref(result);
1360 g_variant_unref(temp);
1363 * As we need to provide async callback to user from HAL, simply schedule a
1364 * callback method which will carry actual result
1366 g_idle_add(__bt_adapter_local_version_cb, (gpointer) version);
1369 return BT_STATUS_SUCCESS;
1372 /* Get Local Name API and callback */
1373 static gboolean __bt_adapter_local_name_cb(gpointer user_data)
1375 /* Buffer and propety count management */
1376 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1377 struct hal_ev_adapter_props_changed *ev = (void*) buf;;
1381 memset(buf, 0, sizeof(buf));
1384 ev->status = BT_STATUS_SUCCESS;
1386 name = (char*) user_data;
1387 DBG("Local Name in callback: [%s]", name);
1389 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_NAME,
1390 strlen(name) + 1, name);
1393 DBG("Device name [%s] property Num [%d]", name, ev->num_props);
1396 event_cb = _bt_get_adapter_event_cb();
1398 ERR("event_cb is NULL");
1403 DBG("Send Adapter Properties changed event to HAL user,"
1404 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1405 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1412 int _bt_hal_dbus_get_local_name(void)
1415 const char *name = NULL;
1418 GError *error = NULL;
1420 proxy = _bt_hal_get_adapter_properties_proxy();
1422 DBG("Adapter Properties proxy get failed!!!");
1423 return BT_STATUS_FAIL;
1426 result = g_dbus_proxy_call_sync(proxy,
1428 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1430 G_DBUS_CALL_FLAGS_NONE,
1436 if (error != NULL) {
1437 ERR("Failed to get local name (Error: %s)", error->message);
1438 g_clear_error(&error);
1440 ERR("Failed to get local name");
1441 return BT_STATUS_FAIL;
1444 g_variant_get(result, "(v)", &temp);
1445 name = g_variant_dup_string(temp, NULL);
1446 DBG("Local Name: [%s]", name);
1448 g_variant_unref(result);
1449 g_variant_unref(temp);
1452 * As we need to provide async callback to user from HAL, simply schedule a
1453 * callback method which will carry actual result
1455 g_idle_add(__bt_adapter_local_name_cb, (gpointer) name);
1457 return BT_STATUS_SUCCESS;
1460 /* Get Local Address API and callback */
1461 static gboolean __bt_adapter_local_address_cb(gpointer user_data)
1463 /* Buffer and propety count management */
1464 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1465 struct hal_ev_adapter_props_changed *ev = (void*) buf;
1467 char * address = NULL;
1469 memset(buf, 0, sizeof(buf));
1472 ev->status = BT_STATUS_SUCCESS;
1474 address = (char*) user_data;
1477 _bt_hal_convert_addr_string_to_type(bdaddr, address);
1479 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
1480 sizeof(bdaddr), bdaddr);
1483 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
1485 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_ADDR,
1486 sizeof(bdaddr), bdaddr);
1489 event_cb = _bt_get_adapter_event_cb();
1491 ERR("event_cb is NULL");
1496 DBG("Send Device found event to HAL user,"
1497 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1498 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1505 int _bt_hal_dbus_get_local_address(void)
1508 GError *error = NULL;
1509 const char *address;
1513 proxy = _bt_hal_get_adapter_properties_proxy();
1515 DBG("_bt_hal_dbus_get_local_address: Adapter Properties proxy get failed!!!");
1516 return BT_STATUS_FAIL;
1519 result = g_dbus_proxy_call_sync(proxy,
1521 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1523 G_DBUS_CALL_FLAGS_NONE,
1529 ERR("Failed to get local address");
1530 if (error != NULL) {
1531 ERR("Failed to get local address (Error: %s)", error->message);
1532 g_clear_error(&error);
1534 return BT_STATUS_FAIL;
1537 g_variant_get(result, "(v)", &temp);
1538 address = g_variant_dup_string(temp, NULL);
1541 DBG("Address:%s", address);
1543 return BT_STATUS_FAIL;
1545 g_variant_unref(result);
1546 g_variant_unref(temp);
1549 * As we need to provide async callback to user from HAL, simply schedule a
1550 * callback method which will carry actual result
1552 g_idle_add(__bt_adapter_local_address_cb, (gpointer) address);
1554 return BT_STATUS_SUCCESS;
1557 /* Get Local services API and callback */
1558 static gboolean __bt_adapter_service_uuids_cb(gpointer user_data)
1560 GVariant *result = user_data;
1562 GVariantIter *iter = NULL;
1565 /* Buffer and propety count management */
1566 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1567 struct hal_ev_adapter_props_changed *ev = (void*) buf;
1570 /* UUID collection */
1571 uint8_t uuids[HAL_UUID_LEN * MAX_UUID_COUNT];
1574 memset(buf, 0, sizeof(buf));
1577 ev->status = BT_STATUS_SUCCESS;
1579 g_variant_get(result, "(v)", &temp);
1580 g_variant_get(temp, "as", &iter);
1582 ERR("Failed to get UUIDs");
1586 while (g_variant_iter_loop(iter, "s", &uuid_str)) {
1587 uint8_t uuid[HAL_UUID_LEN];
1589 DBG("UUID string [%s]\n", uuid_str);
1590 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
1591 memcpy(uuids + uuid_count * HAL_UUID_LEN, uuid, HAL_UUID_LEN);
1595 size += __bt_insert_hal_properties(buf + size,
1596 HAL_PROP_ADAPTER_UUIDS,
1597 (HAL_UUID_LEN * uuid_count),
1602 event_cb = _bt_get_adapter_event_cb();
1604 ERR("event_cb is NULL");
1609 DBG("Send Adapter properties changed event to HAL user,"
1610 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1611 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1614 g_variant_iter_free(iter);
1615 g_variant_unref(result);
1616 g_variant_unref(temp);
1620 event_cb = _bt_get_adapter_event_cb();
1622 ev->status = BT_STATUS_FAIL;
1624 DBG("Send Adapter properties changed event to HAL user,"
1625 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1626 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1629 g_variant_unref(result);
1633 int _bt_hal_dbus_get_adapter_supported_uuids(void)
1636 GError *error = NULL;
1639 proxy = _bt_hal_get_adapter_properties_proxy();
1641 DBG("Adapter Properties proxy get failed!!!");
1642 return BT_STATUS_FAIL;
1645 result = g_dbus_proxy_call_sync(proxy,
1647 g_variant_new("(ss)", BT_HAL_ADAPTER_INTERFACE,
1649 G_DBUS_CALL_FLAGS_NONE,
1655 if (error != NULL) {
1656 ERR("Failed to get UUIDs (Error: %s)", error->message);
1657 g_clear_error(&error);
1659 ERR("Failed to get UUIDs");
1660 return BT_STATUS_FAIL;
1664 DBG("Got All Adaptr service UUID's from Bluez Stack!!, time to start parsing");
1667 * As we need to provide async callback to user from HAL, simply schedule a
1668 * callback method which will carry actual result
1670 g_idle_add(__bt_adapter_service_uuids_cb, (gpointer)result);
1672 return BT_STATUS_SUCCESS;
1675 static gboolean __is_device_paired(GVariantIter *item_iter)
1677 gboolean paired = FALSE;
1681 while (g_variant_iter_loop(item_iter, "{sv}", &key, &value)) {
1682 if (NULL == key || g_strcmp0(key, "Paired"))
1685 paired = g_variant_get_boolean(value);
1686 g_variant_unref(value);
1694 static gboolean __bt_adapter_bonded_devices_cb(gpointer user_data)
1696 /* Buffer and propety count management */
1697 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1698 uint8_t addresses[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1699 struct hal_ev_adapter_props_changed *ev = (void *)buf;
1703 GVariant *result = user_data;
1705 GVariantIter *interface_iter;
1706 GVariantIter *svc_iter;
1707 char *object_path = NULL;
1708 char *interface_str = NULL;
1710 char device_address[BT_HAL_ADDRESS_STRING_SIZE];
1711 uint8_t bdaddr[BT_HAL_ADDRESS_LENGTH_MAX];
1713 memset(buf, 0, sizeof(buf));
1716 ev->status = BT_STATUS_SUCCESS;
1718 INFO("Size [%zd]", size);
1720 /* signature of GetManagedObjects: a{oa{sa{sv}}} */
1721 g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
1723 /* Parse the signature: {oa{sa{sv}}} */
1724 while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
1725 if (object_path == NULL)
1728 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
1729 &interface_str, &svc_iter)) {
1730 if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
1731 DBG("Found a device: %s", object_path);
1732 if (__is_device_paired(svc_iter)) {
1733 _bt_hal_convert_device_path_to_address(object_path, device_address);
1734 DBG("Paired Device Address: [%s]", device_address);
1736 _bt_hal_convert_addr_string_to_type(bdaddr, device_address);
1737 memcpy((addresses + (count * BT_HAL_ADDRESS_LENGTH_MAX)),
1738 bdaddr, BT_HAL_ADDRESS_LENGTH_MAX);
1741 g_variant_iter_free(svc_iter);
1742 g_free(interface_str);
1743 interface_str = NULL;
1748 if (count >= (int)(sizeof(addresses) / BT_HAL_ADDRESS_LENGTH_MAX)) {
1749 DBG("Reached the max length of addresses. do not stored anymore");
1754 g_variant_iter_free(iter);
1755 g_variant_unref(result);
1757 size += __bt_insert_hal_properties((buf + size),
1758 HAL_PROP_ADAPTER_BONDED_DEVICES,
1759 (count * BT_HAL_ADDRESS_LENGTH_MAX), addresses);
1763 event_cb = _bt_get_adapter_event_cb();
1765 ERR("event_cb is NULL");
1770 DBG("Send Adapter properties changed event to HAL user,"
1771 " Num Prop [%d] total size [%zd]", ev->num_props, size);
1772 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, (void*) buf, size);
1778 int _bt_hal_dbus_get_bonded_devices(void)
1780 GDBusProxy *manager_proxy;
1781 GVariant *result = NULL;
1783 manager_proxy = _bt_hal_get_manager_proxy();
1784 if (manager_proxy == NULL)
1785 return BT_STATUS_FAIL;
1787 result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
1789 G_DBUS_CALL_FLAGS_NONE,
1794 ERR("Can't get managed objects");
1795 return BT_STATUS_FAIL;
1799 * As we need to provide async callback to user from HAL, simply schedule a
1800 * callback method which will carry actual result
1802 g_idle_add(__bt_adapter_bonded_devices_cb, (gpointer) result);
1804 return BT_STATUS_SUCCESS;
1807 int _bt_hal_dbus_get_adapter_property(bt_property_type_t property_type)
1809 DBG("property_type: %d", property_type);
1811 switch (property_type) {
1812 case BT_PROPERTY_BDADDR:
1813 return _bt_hal_dbus_get_local_address();
1814 case BT_PROPERTY_BDNAME:
1815 return _bt_hal_dbus_get_local_name();
1816 case BT_PROPERTY_VERSION:
1817 return _bt_hal_dbus_get_local_version();
1818 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
1819 return _bt_hal_dbus_get_discovery_timeout();
1820 case BT_PROPERTY_ADAPTER_SCAN_MODE:
1821 return _bt_hal_dbus_get_scan_mode();
1822 case BT_PROPERTY_CLASS_OF_DEVICE:
1823 return BT_STATUS_UNSUPPORTED;
1824 case BT_PROPERTY_UUIDS:
1825 return _bt_hal_dbus_get_adapter_supported_uuids();
1826 case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
1827 return _bt_hal_dbus_get_bonded_devices();
1829 return BT_STATUS_UNSUPPORTED;
1833 static int __bt_hal_dbus_set_local_name(void *data)
1836 const char *name = data;
1838 GError *error = NULL;
1840 DBG("Local Name: [%s]", name);
1841 proxy = _bt_hal_get_adapter_properties_proxy();
1843 DBG("_bt_hal_dbus_get_local_name: Adapter Properties proxy get failed!!!");
1844 return BT_STATUS_FAIL;
1847 result = g_dbus_proxy_call_sync(proxy,
1849 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE,
1850 "Alias", g_variant_new("s", name)),
1851 G_DBUS_CALL_FLAGS_NONE,
1856 if (error != NULL) {
1857 ERR("Failed to set local name (Error: %s)", error->message);
1858 g_clear_error(&error);
1860 ERR("Failed to set local name");
1861 return BT_STATUS_FAIL;
1863 g_variant_unref(result);
1865 return BT_STATUS_SUCCESS;
1868 static int __bt_hal_dbus_set_scan_mode(void *data)
1873 GError *error = NULL;
1877 DBG("Scan mode: [%d]", *mode);
1878 proxy = _bt_hal_get_adapter_properties_proxy();
1880 DBG("Adapter Properties proxy get failed!!!");
1881 return BT_STATUS_FAIL;
1885 case BT_SCAN_MODE_NONE:
1889 case BT_SCAN_MODE_CONNECTABLE:
1893 case BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE:
1898 ERR("Invalid scan mode");
1899 return BT_STATUS_FAIL;
1902 result = g_dbus_proxy_call_sync(proxy,
1904 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE,
1905 "Connectable", g_variant_new("b", pg_scan)),
1906 G_DBUS_CALL_FLAGS_NONE,
1911 if (error != NULL) {
1912 ERR("Failed to set connectable property (Error: %s)", error->message);
1913 g_clear_error(&error);
1915 ERR("Failed to set connectable property");
1916 return BT_STATUS_FAIL;
1918 g_variant_unref(result);
1920 result = g_dbus_proxy_call_sync(proxy,
1922 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE, "Discoverable",
1923 g_variant_new("b", inq_scan)),
1924 G_DBUS_CALL_FLAGS_NONE,
1929 if (error != NULL) {
1930 ERR("Failed to set Discoverable property (Error: %s)", error->message);
1931 g_clear_error(&error);
1933 ERR("Failed to set Discoverable property");
1934 return BT_STATUS_FAIL;
1936 g_variant_unref(result);
1938 return BT_STATUS_SUCCESS;
1941 static int __bt_hal_dbus_set_discovery_timeout(void *data)
1944 unsigned int *timeout = data;
1946 GError *error = NULL;
1948 DBG("Discovery Timeout: [%d]", *timeout);
1949 proxy = _bt_hal_get_adapter_properties_proxy();
1951 DBG("Adapter Properties proxy get failed!!!");
1952 return BT_STATUS_FAIL;
1955 result = g_dbus_proxy_call_sync(proxy,
1957 g_variant_new("(ssv)", BT_HAL_ADAPTER_INTERFACE,
1958 "DiscoverableTimeout", g_variant_new("u", *timeout)),
1959 G_DBUS_CALL_FLAGS_NONE,
1964 if (error != NULL) {
1965 ERR("Failed to set DiscoverableTimeout property (Error: %s)", error->message);
1966 g_clear_error(&error);
1968 ERR("Failed to set DiscoverableTimeout property");
1969 return BT_STATUS_FAIL;
1971 g_variant_unref(result);
1973 return BT_STATUS_SUCCESS;
1976 /* Set Adapter Properties */
1977 int _bt_hal_dbus_set_adapter_property(const bt_property_t *property)
1981 if (property == NULL || property->val == NULL) {
1982 ERR("Invalid parameters received");
1983 return BT_STATUS_FAIL;
1986 switch (property->type) {
1987 case BT_PROPERTY_BDNAME:
1988 result = __bt_hal_dbus_set_local_name(property->val);
1990 case BT_PROPERTY_ADAPTER_SCAN_MODE:
1991 result = __bt_hal_dbus_set_scan_mode(property->val);
1993 case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
1994 result = __bt_hal_dbus_set_discovery_timeout(property->val);
1997 result = BT_STATUS_UNSUPPORTED;