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.
32 #include <bundle_internal.h>
36 #include "bt-hal-log.h"
37 #include "bt-hal-msg.h"
38 #include "bt-hal-utils.h"
39 #include "bt-hal-internal.h"
40 #include "bt-hal-event-receiver.h"
41 #include "bt-hal-dbus-common-utils.h"
43 #include "bt-hal-adapter-dbus-handler.h"
44 #include "bt-hal-device-dbus-handler.h"
45 #include "bt-hal-event-receiver.h"
46 #include "bt-hal-agent.h"
47 #include "bt-hal-gap-agent.h"
49 #define PROFILE_SUPPORTED 0x03
50 #define PROFILE_TRUSTED 0x02
51 #define PROFILE_BLOCKED 0x01
53 static handle_stack_msg event_cb = NULL;
55 /* Forward Delcaration */
56 static void __bt_hal_bond_device_cb(GDBusProxy *proxy, GAsyncResult *res, gpointer user_data);
58 static void __bt_hal_unbond_device_cb(GDBusProxy *proxy, GAsyncResult *res,
60 static void __bt_hal_device_service_search_cb(GDBusProxy *proxy, GAsyncResult *res,
62 int __bt_hal_dbus_enquire_remote_device_services(char *address);
64 static void __bt_device_parse_services(GVariant *result);
66 int _bt_hal_device_create_bond(const bt_bdaddr_t *bd_addr, unsigned short transport)
69 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
71 GDBusConnection *conn;
72 char *device_path = NULL;
73 GDBusProxy *adapter_proxy;
75 struct hal_ev_bond_state_changed ev;
76 memset(&ev, 0, sizeof(ev));
79 DBG("Transport [0x%x] Add[0x%x] [0x%x][0x%x][0x%x][0x%x][0x%x]",
80 transport, bd_addr->address[0], bd_addr->address[1],
81 bd_addr->address[2], bd_addr->address[3],
82 bd_addr->address[4], bd_addr->address[5]);
83 conn = _bt_hal_get_system_gconn();
85 DBG("Could not get DBUS connection!");
86 return BT_STATUS_FAIL;
89 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
90 device_path = _bt_hal_get_device_object_path(address);
92 if (device_path == NULL) {
93 ERR("No searched device, attempt to create device");
95 adapter_proxy = _bt_hal_get_adapter_proxy();
97 ERR("Could not get Adapter Proxy");
98 return BT_STATUS_FAIL;
101 ret = g_dbus_proxy_call_sync(adapter_proxy, "CreateDevice",
102 g_variant_new("(s)", address),
103 G_DBUS_CALL_FLAGS_NONE,
109 ERR("CreateDevice Fail: %s", error->message);
110 g_clear_error(&error);
113 g_variant_unref(ret);
114 device_path = _bt_hal_get_device_object_path(address);
116 if (device_path == NULL) {
117 ERR("Device path is still not created!!");
118 return BT_STATUS_FAIL;
120 DBG("Device_path is created[%s]", device_path);
123 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
124 NULL, BT_HAL_BLUEZ_NAME,
125 device_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
129 ERR("Could not get Device Proxy");
130 return BT_STATUS_FAIL;
133 g_dbus_proxy_call(proxy, "Pair",
134 g_variant_new("(y)", transport),
135 G_DBUS_CALL_FLAGS_NONE,
136 BT_HAL_MAX_DBUS_TIMEOUT,
138 (GAsyncReadyCallback)__bt_hal_bond_device_cb,
141 /* Prepare to send Bonding event event to HAL bluetooth */
142 ev.status = BT_STATUS_SUCCESS;
143 ev.state = BT_BOND_STATE_BONDING;
145 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
148 event_cb = _bt_hal_get_stack_message_handler();
150 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
151 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
155 return BT_STATUS_SUCCESS;
158 int _bt_hal_device_remove_bond(const bt_bdaddr_t *bd_addr)
160 char *device_path = NULL;
161 GDBusProxy *adapter_proxy = NULL;
162 GDBusProxy *device_proxy = NULL;
163 GDBusConnection *conn;
164 GError *error = NULL;
165 GVariant *ret = NULL;
166 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
168 DBG("Add[0x%x] [0x%x][0x%x][0x%x][0x%x][0x%x]",
169 bd_addr->address[0], bd_addr->address[1],
170 bd_addr->address[2], bd_addr->address[3],
171 bd_addr->address[4], bd_addr->address[5]);
173 adapter_proxy = _bt_hal_get_adapter_proxy();
174 if (!adapter_proxy) {
175 ERR("Could not get Adapter Proxy");
176 return BT_STATUS_FAIL;
179 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
181 device_path = _bt_hal_get_device_object_path(address);
183 /* This is a special case, bluedroid always sends success to HAL even if device is already removed
184 whereas bluez sends BLUETOOTH_ERROR_NOT_PAIRED. However we will return Failure
186 if (device_path == NULL) {
187 ERR("No paired device");
188 return BT_STATUS_FAIL;
191 conn = _bt_hal_get_system_gconn();
195 return BT_STATUS_FAIL;
199 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
200 NULL, BT_HAL_BLUEZ_NAME,
201 device_path, BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
203 if (device_proxy != NULL) {
205 ret = g_dbus_proxy_call_sync(device_proxy, "Get",
206 g_variant_new("(ss)", BT_HAL_DEVICE_INTERFACE, "Paired"),
207 G_DBUS_CALL_FLAGS_NONE,
212 ERR("Getting property failed: [%s]\n", error->message);
214 return BT_STATUS_FAIL;
217 ERR("No paired device");
218 g_object_unref(device_proxy);
219 return BT_STATUS_FAIL;
221 g_variant_unref(ret);
223 g_object_unref(device_proxy);
226 g_dbus_proxy_call(adapter_proxy, "UnpairDevice",
227 g_variant_new("(o)", device_path),
228 G_DBUS_CALL_FLAGS_NONE,
229 BT_HAL_MAX_DBUS_TIMEOUT,
231 (GAsyncReadyCallback)__bt_hal_unbond_device_cb,
232 (gpointer)device_path);
235 return BT_STATUS_SUCCESS;
238 int _bt_hal_device_cancel_bond(const bt_bdaddr_t *bd_addr)
240 int result = BT_STATUS_SUCCESS;
243 result = _bt_hal_agent_reply_cancellation();
244 if (result != BT_HAL_ERROR_NONE) {
245 ERR("Fail to call reply cancellation");
246 return BT_STATUS_FAIL;
249 _bt_hal_agent_set_canceled(TRUE);
253 int _bt_hal_device_legacy_pin_reply(const bt_bdaddr_t *bd_addr,
254 gboolean accept, uint8_t pin_len, char *pincode)
256 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
260 return BT_STATUS_FAIL;
262 DBG("pin_len [0x%x]", pin_len);
263 DBG("pincode [%s]", pincode);
266 gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, pincode, NULL);
268 gap_agent_reply_pin_code(agent, GAP_AGENT_REJECT, NULL, NULL);
271 return BT_STATUS_SUCCESS;
274 int _bt_hal_device_ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
275 uint8_t accept, uint32_t passkey)
277 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
281 return BT_STATUS_FAIL;
284 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
285 DBG("SSP: PASSKEY_CONFIRMATION");
287 gap_agent_reply_confirmation(agent, GAP_AGENT_ACCEPT, NULL);
289 gap_agent_reply_confirmation(agent, GAP_AGENT_REJECT, NULL);
291 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
292 DBG("SSP: PASSKEY_NOTIFICATION");
294 case BT_SSP_VARIANT_PASSKEY_ENTRY:
295 DBG("SSP: PASSKEY_ENTRY");
298 snprintf(str_passkey, sizeof(str_passkey), "%.6d", passkey);
299 DBG("Passkey [%s]", str_passkey);
300 gap_agent_reply_passkey(agent, GAP_AGENT_ACCEPT, str_passkey, NULL);
302 gap_agent_reply_passkey(agent, GAP_AGENT_REJECT, NULL, NULL);
304 case BT_SSP_VARIANT_CONSENT:
305 DBG("SSP: VARIANT_CONSENT: Unhandled!");
312 return BT_STATUS_SUCCESS;
315 int _bt_hal_dbus_get_remote_device_services(const bt_bdaddr_t *remote_addr)
317 char *device_path = NULL;
318 GDBusProxy *device_proxy = NULL;
319 GDBusConnection *conn;
320 GDBusProxy *adapter_proxy;
321 //char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
322 char *address = NULL;
323 int result = BT_STATUS_SUCCESS;
326 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
328 _bt_hal_convert_addr_type_to_string(address, remote_addr->address);
330 if (remote_addr == NULL) {
331 result = BT_STATUS_PARM_INVALID;
335 adapter_proxy = _bt_hal_get_adapter_proxy();
336 if (adapter_proxy == NULL) {
337 result = BT_STATUS_FAIL;
341 conn = _bt_hal_get_system_gconn();
343 ERR("Could not get System DBUS Connection");
344 result = BT_STATUS_FAIL;
348 device_path = _bt_hal_get_device_object_path(address);
350 if (device_path == NULL) {
351 ERR("Remote device is not paired..can not perform SDP!!!");
352 result = BT_STATUS_FAIL;
356 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
357 NULL, BT_HAL_BLUEZ_NAME,
358 device_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
361 if (device_proxy == NULL) {
362 ERR("Could not create Device Proxy");
363 result = BT_STATUS_FAIL;
368 g_dbus_proxy_call(device_proxy, "DiscoverServices",
369 g_variant_new("(s)", ""),
370 G_DBUS_CALL_FLAGS_NONE,
371 BT_HAL_MAX_DBUS_TIMEOUT,
373 (GAsyncReadyCallback)__bt_hal_device_service_search_cb,
376 return BT_STATUS_SUCCESS;
383 int _bt_hal_device_authorize_response(const bt_bdaddr_t *bd_addr, bt_service_id_t service_id,
384 uint8_t authorize, uint8_t save_settings)
386 int reply = GAP_AGENT_ACCEPT;
387 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
391 return BT_STATUS_FAIL;
394 reply = GAP_AGENT_REJECT;
395 else if (authorize && save_settings)
396 reply = GAP_AGENT_ACCEPT_ALWAYS;
398 gap_agent_reply_authorize(agent, reply, NULL);
401 return BT_STATUS_SUCCESS;
404 int _bt_hal_device_set_trust(const bt_bdaddr_t *bd_addr, uint8_t trust)
406 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
407 gchar *device_path = NULL;
408 GDBusProxy *device_proxy;
409 gboolean previous_value;
411 GDBusConnection *conn;
412 GError *error = NULL;
413 GVariant *result = NULL;
414 GVariant *temp = NULL;
415 int ret = BT_STATUS_SUCCESS;
419 return BT_STATUS_PARM_INVALID;
426 conn = _bt_hal_get_system_gconn();
429 ERR("Failed to get DBUS connection");
430 return BT_STATUS_FAIL;
433 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
435 device_path = _bt_hal_get_device_object_path(address);
437 if (device_path == NULL) {
438 ERR("No paired device");
439 return BT_STATUS_FAIL;
442 DBG("Device path [%s]", device_path);
443 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
444 NULL, BT_HAL_BLUEZ_NAME,
445 device_path, BT_HAL_PROPERTIES_INTERFACE, NULL, &error);
449 if (device_proxy == NULL) {
451 g_dbus_error_strip_remote_error(error);
452 ERR("Device proxy get failed %s", error->message);
455 ERR("Failed to get Device Proxy");
456 return BT_STATUS_FAIL;
459 result = g_dbus_proxy_call_sync(device_proxy, "Get",
460 g_variant_new("(ss)", BT_HAL_DEVICE_INTERFACE, "Trusted"),
461 G_DBUS_CALL_FLAGS_NONE,
467 ERR("Getting property failed: [%s]\n", error->message);
469 g_object_unref(device_proxy);
470 return BT_STATUS_FAIL;
474 g_variant_get(result, "(v)", &temp);
475 previous_value = g_variant_get_boolean(temp);
476 DBG("Previous value [%d]", previous_value);
478 /* If the input is same with previous value, return error. */
479 if (previous_value == authorize) {
480 ERR("Same value: %d", previous_value);
481 g_object_unref(device_proxy);
482 g_object_unref(result);
483 g_object_unref(temp);
484 return BT_STATUS_PARM_INVALID;
487 DBG("Set authotrize [%d]", authorize);
488 result = g_dbus_proxy_call_sync(device_proxy, "Set",
489 g_variant_new("(ssv)", BT_HAL_DEVICE_INTERFACE, "Trusted", g_variant_new("b", authorize)),
490 G_DBUS_CALL_FLAGS_NONE,
496 ERR("SetProperty error: [%s]", error->message);
498 ret = BT_STATUS_FAIL;
501 g_object_unref(device_proxy);
504 g_object_unref(result);
506 g_object_unref(temp);
512 static void __bt_hal_device_service_search_cb(GDBusProxy *proxy, GAsyncResult *res,
515 /* Buffer and propety count management */
516 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
517 struct hal_ev_remote_device_props *ev = (void*) buf;;
521 int result = BT_HAL_ERROR_NONE;
522 char *address = (char*) user_data;
525 g_dbus_proxy_call_finish(proxy, res, &err);
527 g_object_unref(proxy);
529 /* Check event pointer */
531 event_cb = _bt_hal_get_stack_message_handler();
533 ERR("event_cb is NULL, can not send Service search results to HAL User");
538 g_dbus_error_strip_remote_error(err);
539 ERR("Error occured in Proxy call [%s]\n", err->message);
541 if (g_strrstr("Operation canceled", err->message))
542 result = BT_HAL_ERROR_CANCEL_BY_USER;
543 else if (g_strrstr("In Progress", err->message))
544 result = BT_HAL_ERROR_IN_PROGRESS;
545 else if (g_strrstr("Host is down", err->message))
546 result = BT_HAL_ERROR_HOST_DOWN;
548 result = BT_HAL_ERROR_CONNECTION_ERROR;
551 if (result == BT_HAL_ERROR_HOST_DOWN ||
552 result == BT_HAL_ERROR_CONNECTION_ERROR) {
553 ERR("Service search has failed due to Host Down or connection error, attempt to find properties");
554 if (__bt_hal_dbus_enquire_remote_device_services(address) == BT_STATUS_SUCCESS)
561 DBG("SDP is successful..lets fetch the device properties..");
562 if (__bt_hal_dbus_enquire_remote_device_services(address) == BT_STATUS_SUCCESS)
565 ev->status = BT_STATUS_FAIL;
568 ERR("Error: Failed to get Remote device properties after SDP,"
569 " Num Prop [%d] total size [%zd]", ev->num_props, size);
570 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
578 static void __bt_device_parse_services(GVariant *result)
580 /* Buffer and propety count management */
581 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
582 struct hal_ev_remote_device_props *ev = (void*) buf;;
585 GVariantIter *property_iter;
589 const gchar *address = NULL;
591 memset(buf, 0, sizeof(buf));
594 ev->status = BT_STATUS_SUCCESS;
596 g_variant_get(result, "(a{sv})", &property_iter);
597 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
598 if (!g_strcmp0(key, "Address")) {
599 address = g_variant_get_string(value, NULL);
600 DBG("Address [%s]", address);
601 _bt_hal_convert_addr_string_to_type(ev->bdaddr, address);
602 } else if (!g_strcmp0(key, "UUIDs")) {
607 size1 = g_variant_get_size(value);
608 int num_props_tmp = ev->num_props;
610 uuid_value = (char **)g_variant_get_strv(value, &size1);
611 for (i = 0; uuid_value[i] != NULL; i++)
613 /* UUID collection */
614 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
615 for (i = 0; uuid_value[i] != NULL; i++) {
616 char *uuid_str = NULL;
617 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
618 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
619 uuid_str = g_strdup(uuid_value[i]);
620 DBG("UUID string [%s]\n", uuid_str);
621 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
622 memcpy(uuids + i * BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
625 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
626 (BT_HAL_STACK_UUID_SIZE * uuid_count), uuids);
627 ev->num_props = num_props_tmp + 1;
631 ERR("Unhandled Property:[%s]", key);
635 DBG("Send Remote Device services to HAL,"
636 " Num Prop [%d] total size [%zd]", ev->num_props, size);
637 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
639 g_variant_unref(result);
642 int __bt_hal_dbus_enquire_remote_device_services(char *address)
644 char *device_path = NULL;
645 GError *error = NULL;
646 GDBusProxy *device_proxy;
647 GDBusConnection *conn;
650 device_path = _bt_hal_get_device_object_path(address);
652 ERR("Device not paired");
653 return BT_STATUS_FAIL;
656 conn = _bt_hal_get_system_gconn();
659 ERR("_bt_hal_get_system_gconn failed");
660 return BT_STATUS_FAIL;
663 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
667 BT_HAL_PROPERTIES_INTERFACE,
671 ERR("Error creating device_proxy");
673 return BT_STATUS_FAIL;
676 result = g_dbus_proxy_call_sync(device_proxy,
678 g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
679 G_DBUS_CALL_FLAGS_NONE,
685 ERR("Error occured in Proxy call");
687 ERR("Error occured in Proxy call (Error: %s)", error->message);
688 g_clear_error(&error);
690 g_object_unref(device_proxy);
692 return BT_STATUS_FAIL;
695 g_object_unref(device_proxy);
698 /* Fetch Device Services and send to HAL User */
699 __bt_device_parse_services(result);
702 return BT_STATUS_SUCCESS;
705 static void __bt_hal_bond_device_cb(GDBusProxy *proxy, GAsyncResult *res,
709 const char *device_path;
710 int result = BT_STATUS_SUCCESS;
711 struct hal_ev_bond_state_changed ev;
712 memset(&ev, 0, sizeof(ev));
713 char dev_address[18];
717 /* Terminate ALL system popup */
718 if (headed_plugin_info->plugin_headed_enabled)
719 headed_plugin_info->headed_plugin->bt_destroy_popup_all();
722 g_dbus_proxy_call_finish(proxy, res, &err);
723 device_path = g_dbus_proxy_get_object_path(proxy);
724 DBG("Device path: %s", device_path);
725 _bt_hal_convert_device_path_to_address(device_path, dev_address);
726 DBG("Remote Device address [%s]", dev_address);
729 g_dbus_error_strip_remote_error(err);
730 ERR("@@@Error occured in CreateBonding [%s]", err->message);
731 if (g_strrstr(err->message, "Already Exists")) {
732 ERR("Still bond existing even after remove");
733 result = BT_STATUS_AUTH_FAILURE;
734 } else if (g_strrstr(err->message, "Authentication Rejected")) {
736 result = BT_STATUS_AUTH_REJECTED;
737 } else if (_bt_hal_agent_is_canceled() ||
738 g_strrstr(err->message, "Authentication Canceled")) {
739 INFO("Cancelled by USER");
740 result = BT_STATUS_AUTH_FAILURE;
741 } else if (g_strrstr(err->message, "In Progress")) {
742 INFO("Bond in progress, cancel and retry");
743 } else if (g_strrstr(err->message, "Authentication Failed")) {
744 INFO("Authentication Failed");
745 result = BT_STATUS_AUTH_FAILURE;
746 } else if (g_strrstr(err->message, "Page Timeout")) {
747 INFO("Page Timeout");
748 /* This is the special case
749 As soon as call bluetooth_bond_device, try to cancel bonding.
750 In this case, before completing to call 'CreatePairedDevice' method
751 the procedure is stopped. So 'Cancle' error is not return.
753 result = BT_STATUS_RMT_DEV_DOWN;
754 } else if (g_strrstr(err->message, BT_HAL_TIMEOUT_MESSAGE)) {
756 result = BT_STATUS_FAIL;
757 } else if (g_strrstr(err->message, "Connection Timeout")) {
758 /* Pairing request timeout */
759 result = BT_STATUS_RMT_DEV_DOWN;
760 } else if (g_strrstr(err->message, "Authentication Timeout")) {
761 /* Pairing request timeout */
762 result = BT_STATUS_AUTH_FAILURE;
764 DBG("Default case: Pairing failed");
765 result = BT_STATUS_AUTH_FAILURE;
769 if (result == BT_STATUS_AUTH_FAILURE ||
770 result == BT_STATUS_RMT_DEV_DOWN ||
771 result == BT_STATUS_AUTH_REJECTED ||
772 result == BT_STATUS_FAIL) {
773 DBG("Bonding Failed!!");
775 /* Prepare to send event to HAL bluetooth */
777 ev.state = BT_BOND_STATE_NONE;
779 _bt_hal_convert_addr_string_to_type(ev.bdaddr, dev_address);
782 event_cb = _bt_hal_get_stack_message_handler();
784 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
785 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
788 DBG("Bonding Success!!");
794 static void __bt_hal_unbond_device_cb(GDBusProxy *proxy, GAsyncResult *res,
798 char *device_path = NULL;
799 char dev_address[18];
800 int result = BT_STATUS_SUCCESS;
801 struct hal_ev_bond_state_changed ev;
802 memset(&ev, 0, sizeof(ev));
805 g_dbus_proxy_call_finish(proxy, res, &err);
807 ERR("Error occured in RemoveBonding [%s]\n", err->message);
808 result = BT_STATUS_FAIL;
812 device_path = (char *)user_data;
813 if (result != BT_STATUS_SUCCESS) {
814 /* Prepare to send event to HAL bluetooth */
816 ev.state = BT_BOND_STATE_NONE;
818 _bt_hal_convert_device_path_to_address(device_path, dev_address);
819 _bt_hal_convert_addr_string_to_type(ev.bdaddr, dev_address);
822 event_cb = _bt_hal_get_stack_message_handler();
824 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
825 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
833 static gboolean __bt_device_bonded_device_info_cb(gpointer user_data)
835 /* Buffer and propety count management */
836 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
837 struct hal_ev_remote_device_props *ev = (void*) buf;;
840 GVariant *result = user_data;
841 GVariantIter *property_iter;
842 GVariantIter *char_value_iter;
844 const gchar *address = NULL;
845 const gchar *name = NULL;
846 unsigned int cod = 0;
851 GByteArray *manufacturer_data = NULL;
855 unsigned int data_len = 0;
856 uint8_t is_alias_set;
858 memset(buf, 0, sizeof(buf));
861 ev->status = BT_STATUS_SUCCESS;
863 g_variant_get(result, "(a{sv})", &property_iter);
864 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
865 if (!g_strcmp0(key, "Address")) {
866 address = g_variant_get_string(value, NULL);
867 DBG("Address [%s]", address);
868 _bt_hal_convert_addr_string_to_type(ev->bdaddr, address);
869 } else if (!g_strcmp0(key, "Alias")) {
870 name = g_variant_get_string(value, NULL);
871 DBG("Alias [%s]", name);
872 size += __bt_insert_hal_properties(buf + size,
873 HAL_PROP_DEVICE_FRIENDLY_NAME, strlen(name) + 1, name);
875 } else if (!g_strcmp0(key, "Class")) {
876 cod = g_variant_get_uint32(value);
877 DBG("Class [%d]", cod);
878 size += __bt_insert_hal_properties(buf + size,
879 HAL_PROP_DEVICE_CLASS, sizeof(unsigned int), &cod);
881 } else if (!g_strcmp0(key, "Connected")) {
882 connected = g_variant_get_byte(value);
883 DBG("Connected [%d]", connected);
884 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
885 sizeof(unsigned int), &connected);
887 } else if (!g_strcmp0(key, "Paired")) {
888 paired = (g_variant_get_boolean(value) ? 1 : 0);
889 DBG("Paired [%d]", paired);
890 size += __bt_insert_hal_properties(buf + size,
891 HAL_PROP_DEVICE_PAIRED, sizeof(uint8_t), &paired);
893 } else if (!g_strcmp0(key, "Trusted")) {
894 trust = (g_variant_get_boolean(value) ? 1 : 0);
895 DBG("Trusted [%d]", trust);
896 size += __bt_insert_hal_properties(buf + size,
897 HAL_PROP_DEVICE_TRUSTED, sizeof(uint8_t), &trust);
899 } else if (!g_strcmp0(key, "Name")) {
900 name = g_variant_get_string(value, NULL);
901 DBG("Name [%s]", name);
902 size += __bt_insert_hal_properties(buf + size,
903 HAL_PROP_DEVICE_NAME, strlen(name) + 1, name);
905 } else if (!g_strcmp0(key, "RSSI")) {
906 rssi = g_variant_get_int16(value);
907 DBG("RSSI [%d]", rssi);
908 size += __bt_insert_hal_properties(buf + size,
909 HAL_PROP_DEVICE_RSSI, sizeof(unsigned int), &rssi);
911 } else if (!g_strcmp0(key, "UUIDs")) {
916 size1 = g_variant_get_size(value);
917 int num_props_tmp = ev->num_props;
919 uuid_value = (char **)g_variant_get_strv(value, &size1);
920 for (i = 0; uuid_value[i] != NULL; i++)
922 /* UUID collection */
923 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
924 for (i = 0; uuid_value[i] != NULL; i++) {
925 char *uuid_str = NULL;
926 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
927 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
928 uuid_str = g_strdup(uuid_value[i]);
929 DBG("UUID string [%s]\n", uuid_str);
930 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
931 memcpy(uuids + i * BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
934 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
935 (BT_HAL_STACK_UUID_SIZE * uuid_count), uuids);
936 ev->num_props = num_props_tmp + 1;
939 } else if (!g_strcmp0(key, "LegacyManufacturerDataLen")) {
940 data_len = g_variant_get_uint16(value);
941 DBG("LegacyManufacturerDataLen [%d]", data_len);
942 } else if (!g_strcmp0(key, "LegacyManufacturerData")) {
943 manufacturer_data = g_byte_array_new();
944 g_variant_get(value, "ay", &char_value_iter);
945 while (g_variant_iter_loop(char_value_iter, "y", &char_value))
946 g_byte_array_append(manufacturer_data, &char_value, 1);
948 if (manufacturer_data) {
949 if (manufacturer_data->len > 0) {
950 size += __bt_insert_hal_properties(
951 buf + size, HAL_PROP_DEVICE_BLE_ADV_DATA,
952 manufacturer_data->len, manufacturer_data->data);
956 g_byte_array_free(manufacturer_data, FALSE);
957 } else if (!g_strcmp0(key, "IsAliasSet")) {
958 is_alias_set = (g_variant_get_boolean(value) ? 1 : 0);
959 DBG("IsAliasSet: %s", ((is_alias_set == 1) ? "TRUE" : "FALSE"));
960 size += __bt_insert_hal_properties(buf + size,
961 HAL_PROP_DEVICE_IS_ALIAS_SET, sizeof(uint8_t), &is_alias_set);
964 ERR("Unhandled Property:[%s]", key);
968 DBG("trust: %d, paired: %d", trust, paired);
970 event_cb = _bt_hal_get_stack_message_handler();
972 ERR("event_cb is NULL");
976 if ((paired == 0) && (trust == 0)) {
977 ev->status = BT_STATUS_FAIL;
980 DBG("Send Remote Device properties event to HAL,"
981 " Num Prop [%d] total size [%zd]", ev->num_props, size);
982 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
985 DBG("Send Remote Device properties event to HAL,"
986 " Num Prop [%d] total size [%zd]", ev->num_props, size);
987 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
992 g_variant_unref(result);
996 int _bt_hal_dbus_get_remote_device_properties(bt_bdaddr_t *remote_addr)
998 char *device_path = NULL;
999 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
1000 GError *error = NULL;
1001 GDBusProxy *device_proxy;
1002 GDBusConnection *conn;
1006 ERR("Invalid device address ptr received");
1007 return BT_STATUS_PARM_INVALID;
1010 _bt_hal_convert_addr_type_to_string(address, remote_addr->address);
1011 device_path = _bt_hal_get_device_object_path(address);
1013 ERR("Device not paired");
1014 return BT_STATUS_FAIL;
1017 conn = _bt_hal_get_system_gconn();
1019 g_free(device_path);
1020 ERR("_bt_hal_get_system_gconn failed");
1021 return BT_STATUS_FAIL;
1024 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1028 BT_HAL_PROPERTIES_INTERFACE,
1031 if (!device_proxy) {
1032 ERR("Error creating device_proxy");
1033 g_free(device_path);
1034 return BT_STATUS_FAIL;
1037 result = g_dbus_proxy_call_sync(device_proxy,
1039 g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
1040 G_DBUS_CALL_FLAGS_NONE,
1046 ERR("Error occured in Proxy call");
1047 if (error != NULL) {
1048 ERR("Error occured in Proxy call (Error: %s)", error->message);
1049 g_clear_error(&error);
1051 g_object_unref(device_proxy);
1052 g_free(device_path);
1053 return BT_STATUS_FAIL;
1056 g_object_unref(device_proxy);
1057 g_free(device_path);
1059 * As we need to provide async callback to user from HAL, simply schedule a
1060 * callback method which will carry actual result
1062 g_idle_add(__bt_device_bonded_device_info_cb, (gpointer)result);
1065 return BT_STATUS_SUCCESS;
1068 static int __bt_hal_dbus_set_remote_device_alias(bt_bdaddr_t *remote_addr, char *alias)
1070 char address[BT_HAL_ADDRESS_STRING_SIZE];
1071 gchar *device_path = NULL;
1072 GDBusProxy *adapter_proxy;
1073 GDBusProxy *device_proxy;
1074 GError *error = NULL;
1075 GDBusConnection *conn;
1078 adapter_proxy = _bt_hal_get_adapter_proxy();
1079 if (!adapter_proxy) {
1080 ERR("Could not get Adapter Proxy");
1081 return BT_STATUS_FAIL;
1084 conn = _bt_hal_get_system_gconn();
1086 ERR("_bt_hal_get_system_gconn failed");
1087 return BT_STATUS_FAIL;
1090 _bt_hal_convert_addr_type_to_string(address, remote_addr->address);
1091 INFO("Address: %s, Alias: %s", address, alias);
1093 device_path = _bt_hal_get_device_object_path(address);
1094 if (device_path == NULL) {
1095 ERR("No paired device");
1096 return BT_STATUS_FAIL;
1099 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1100 NULL, BT_HAL_BLUEZ_NAME, device_path,
1101 BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
1102 g_free(device_path);
1103 if (!device_proxy) {
1104 ERR("Error creating device_proxy");
1105 return BT_STATUS_FAIL;
1108 result = g_dbus_proxy_call_sync(device_proxy, "Set",
1109 g_variant_new("(ssv)",
1110 BT_HAL_DEVICE_INTERFACE,
1111 "Alias", g_variant_new("s", alias)),
1112 G_DBUS_CALL_FLAGS_NONE,
1116 g_object_unref(device_proxy);
1118 ERR("Error occured in Proxy call");
1119 if (error != NULL) {
1120 ERR("Error occured in Proxy call (Error: %s)", error->message);
1121 g_clear_error(&error);
1123 return BT_STATUS_FAIL;
1125 g_variant_unref(result);
1127 return BT_STATUS_SUCCESS;
1130 /* Set Remote Device Properties */
1131 int _bt_hal_dbus_set_remote_device_property(
1132 bt_bdaddr_t *remote_addr, const bt_property_t *property)
1138 if (remote_addr == NULL) {
1139 ERR("Invalid parameters received");
1140 return BT_STATUS_PARM_INVALID;
1143 if (property == NULL || property->val == NULL) {
1144 ERR("Invalid parameters received");
1145 return BT_STATUS_PARM_INVALID;
1148 switch (property->type) {
1149 case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
1150 result = __bt_hal_dbus_set_remote_device_alias(
1151 remote_addr, (char *) property->val);
1154 result = BT_STATUS_UNSUPPORTED;
1157 DBG("Result= [%d]", result);
1162 int _bt_hal_device_get_connection_state(const bt_bdaddr_t *bd_addr)
1164 char address[BT_HAL_ADDRESS_STRING_SIZE];
1165 gchar *device_path = NULL;
1166 GDBusProxy *adapter_proxy;
1167 GDBusProxy *device_proxy;
1168 GError *error = NULL;
1169 GDBusConnection *conn;
1171 GVariant *tmp_value = NULL;
1172 GVariant *value = NULL;
1173 gboolean is_connected = FALSE;
1176 ERR("bd_addr is NULL");
1180 adapter_proxy = _bt_hal_get_adapter_proxy();
1181 if (!adapter_proxy) {
1182 ERR("Could not get Adapter Proxy");
1186 conn = _bt_hal_get_system_gconn();
1188 ERR("_bt_hal_get_system_gconn failed");
1192 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1193 INFO("Address: %s", address);
1195 device_path = _bt_hal_get_device_object_path(address);
1196 if (device_path == NULL) {
1197 ERR("No paired device");
1201 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1202 NULL, BT_HAL_BLUEZ_NAME, device_path,
1203 BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
1204 g_free(device_path);
1205 if (!device_proxy) {
1206 ERR("Error creating device_proxy");
1210 result = g_dbus_proxy_call_sync(device_proxy, "GetProperties",
1211 g_variant_new("(s)", address),
1212 G_DBUS_CALL_FLAGS_NONE,
1216 g_object_unref(device_proxy);
1218 ERR("Error occured in Proxy call");
1219 if (error != NULL) {
1220 ERR("Error occured in Proxy call (Error: %s)", error->message);
1221 g_clear_error(&error);
1226 g_variant_get(result , "(@a{sv})", &value);
1227 g_variant_unref(result);
1230 tmp_value = g_variant_lookup_value(value,
1232 G_VARIANT_TYPE_BOOLEAN);
1234 is_connected = g_variant_get_boolean(tmp_value);
1235 g_variant_unref(tmp_value);
1237 g_variant_unref(value);
1247 int _bt_hal_device_get_service_connection_state(
1248 const bt_bdaddr_t *bd_addr, bt_service_id_t rem_svc_id)
1250 char address[BT_HAL_ADDRESS_STRING_SIZE];
1251 gchar *device_path = NULL;
1252 GDBusProxy *adapter_proxy;
1253 GDBusProxy *device_proxy;
1254 GError *error = NULL;
1255 GDBusConnection *conn;
1257 gboolean is_connected;
1261 ERR("bd_addr is NULL");
1265 adapter_proxy = _bt_hal_get_adapter_proxy();
1266 if (!adapter_proxy) {
1267 ERR("Could not get Adapter Proxy");
1271 conn = _bt_hal_get_system_gconn();
1273 ERR("_bt_hal_get_system_gconn failed");
1277 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1278 INFO("Address: %s: Remote svc_id: %d", address, rem_svc_id);
1280 device_path = _bt_hal_get_device_object_path(address);
1281 if (device_path == NULL) {
1282 ERR("No paired device");
1286 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1287 NULL, BT_HAL_BLUEZ_NAME, device_path,
1288 BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1289 g_free(device_path);
1290 if (!device_proxy) {
1291 ERR("Error creating device_proxy");
1295 uuid = _bt_convert_service_id_to_uuid_string(rem_svc_id);
1296 DBG("uuid: %s", uuid);
1300 result = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
1301 g_variant_new("(s)", uuid),
1302 G_DBUS_CALL_FLAGS_NONE,
1307 g_object_unref(device_proxy);
1309 ERR("Error occured in Proxy call");
1310 if (error != NULL) {
1311 ERR("Error occured in Proxy call (Error: %s)", error->message);
1312 g_clear_error(&error);
1317 g_variant_get(result, "(b)", &is_connected);
1318 g_variant_unref(result);
1326 int _bt_hal_device_register_osp_server(uint32_t type, char *uuid, char *path, int fd)
1328 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
1329 gboolean result = FALSE;
1333 return BT_STATUS_FAIL;
1335 result = _bt_hal_gap_agent_register_osp_server(agent, type, uuid, path, fd);
1337 return BT_STATUS_FAIL;
1340 return BT_STATUS_SUCCESS;
1343 int _bt_hal_device_unregister_osp_server(uint32_t type, char *uuid)
1345 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
1346 gboolean result = FALSE;
1350 return BT_STATUS_FAIL;
1352 result = _bt_hal_gap_agent_unregister_osp_server(agent, type, uuid);
1354 return BT_STATUS_FAIL;
1357 return BT_STATUS_SUCCESS;
1360 static char* __bt_hal_get_trusted_profile_uuid(bt_trusted_profile_t profile)
1363 case BT_TRUSTED_PROFILE_PBAP:
1364 return g_strdup("00001130-0000-1000-8000-00805f9b34fb");
1365 case BT_TRUSTED_PROFILE_MAP:
1366 return g_strdup("00001134-0000-1000-8000-00805f9b34fb");
1367 case BT_TRUSTED_PROFILE_SAP:
1368 return g_strdup("0000112D-0000-1000-8000-00805f9b34fb");
1369 case BT_TRUSTED_PROFILE_HFP_HF:
1370 return g_strdup("0000111e-0000-1000-8000-00805f9b34fb");
1371 case BT_TRUSTED_PROFILE_A2DP:
1372 return g_strdup("0000110b-0000-1000-8000-00805f9b34fb");
1373 case BT_TRUSTED_PROFILE_ALL:
1380 int _bt_hal_device_set_trusted_profile(const bt_bdaddr_t *bd_addr,
1381 bt_trusted_profile_t profile, uint8_t trust)
1383 char address[BT_HAL_ADDRESS_STRING_SIZE];
1384 gchar *device_path = NULL;
1385 GDBusProxy *adapter_proxy;
1386 GDBusProxy *device_proxy;
1387 GError *error = NULL;
1388 GDBusConnection *conn;
1396 ERR("bd_addr is NULL");
1397 return BT_STATUS_PARM_INVALID;
1400 adapter_proxy = _bt_hal_get_adapter_proxy();
1401 if (!adapter_proxy) {
1402 ERR("Could not get Adapter Proxy");
1403 return BT_STATUS_FAIL;
1406 conn = _bt_hal_get_system_gconn();
1408 ERR("_bt_hal_get_system_gconn failed");
1409 return BT_STATUS_FAIL;
1412 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1413 INFO("Address: %s: profile: %d, trusted: %d", address, profile, trust);
1415 device_path = _bt_hal_get_device_object_path(address);
1416 if (device_path == NULL) {
1417 ERR("No paired device");
1418 return BT_STATUS_FAIL;
1421 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1422 NULL, BT_HAL_BLUEZ_NAME, device_path,
1423 BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1424 g_free(device_path);
1425 if (!device_proxy) {
1426 ERR("Error creating device_proxy");
1427 return BT_STATUS_FAIL;
1430 uuid = __bt_hal_get_trusted_profile_uuid(profile);
1432 ERR("Not supported");
1433 g_object_unref(device_proxy);
1434 return BT_STATUS_UNSUPPORTED;
1437 trusted = ((trust == 0) ? FALSE : TRUE);
1438 DBG("uuid: %s", uuid);
1439 result = g_dbus_proxy_call_sync(device_proxy, "SetTrustedProfile",
1440 g_variant_new("(sb)", uuid, trusted),
1441 G_DBUS_CALL_FLAGS_NONE,
1444 g_object_unref(device_proxy);
1446 ERR("Failed to Set Profile Trusted, Error occured in proxy call");
1447 if (error != NULL) {
1448 ERR("(Error: %s)", error->message);
1449 g_clear_error(&error);
1451 return BT_STATUS_FAIL;
1454 g_variant_unref(result);
1457 return BT_STATUS_SUCCESS;
1460 static int __hal_get_trusted_value_from_flag(bt_trusted_profile_t profile,
1461 uint32_t trusted_flag, uint32_t *trusted)
1467 case BT_TRUSTED_PROFILE_PBAP:
1468 /* Bit 0 & 1 - for PBAP Supported */
1469 trusted_flag = (trusted_flag >> 0);
1471 if (!(trusted_flag & PROFILE_SUPPORTED))
1472 return BT_STATUS_UNSUPPORTED;
1474 *trusted = trusted_flag & PROFILE_TRUSTED;
1475 DBG("Profile %d, trusted: %s", profile,
1476 ((*trusted == 0) ? "FALSE" : "TRUE"));
1478 case BT_TRUSTED_PROFILE_MAP:
1479 /* Bit 2 & 3 - for MAP Supported */
1480 trusted_flag = (trusted_flag >> 2);
1482 if (!(trusted_flag & PROFILE_SUPPORTED))
1483 return BT_STATUS_UNSUPPORTED;
1485 *trusted = trusted_flag & PROFILE_TRUSTED;
1486 DBG("Profile %d, trusted: %s", profile,
1487 ((*trusted == 0) ? "FALSE" : "TRUE"));
1489 case BT_TRUSTED_PROFILE_SAP:
1490 /* Bit 4 & 5 - for SAP Supported */
1491 trusted_flag = (trusted_flag >> 4);
1493 if (!(trusted_flag & PROFILE_SUPPORTED))
1494 return BT_STATUS_UNSUPPORTED;
1496 *trusted = trusted_flag & PROFILE_TRUSTED;
1497 DBG("Profile %d, trusted: %s", profile,
1498 ((*trusted == 0) ? "FALSE" : "TRUE"));
1500 case BT_TRUSTED_PROFILE_HFP_HF:
1501 /* Bit 6 & 7 - for HFP_HF Supported */
1502 trusted_flag = (trusted_flag >> 6);
1504 if (PROFILE_BLOCKED != (trusted_flag & PROFILE_SUPPORTED))
1507 DBG("Profile %d, trusted: %s", profile,
1508 ((*trusted == 0) ? "FALSE" : "TRUE"));
1510 case BT_TRUSTED_PROFILE_A2DP:
1511 /* Bit 8 & 9 - for A2DP Supported */
1512 trusted_flag = (trusted_flag >> 8);
1514 if (PROFILE_BLOCKED != (trusted_flag & PROFILE_SUPPORTED))
1517 DBG("Profile %d, trusted: %s", profile,
1518 ((*trusted == 0) ? "FALSE" : "TRUE"));
1520 case BT_TRUSTED_PROFILE_ALL:
1521 /* Return Flag for All profiles*/
1522 *trusted = trusted_flag;
1523 return BT_STATUS_SUCCESS;
1525 return BT_STATUS_UNSUPPORTED;
1532 return BT_STATUS_SUCCESS;
1535 int _bt_hal_device_get_trusted_profile(const bt_bdaddr_t *bd_addr,
1536 bt_trusted_profile_t profile, uint32_t *trusted)
1538 char address[BT_HAL_ADDRESS_STRING_SIZE];
1539 gchar *device_path = NULL;
1540 GDBusProxy *adapter_proxy;
1541 GDBusProxy *device_proxy;
1542 GError *error = NULL;
1543 GDBusConnection *conn;
1546 uint32_t trusted_flag;
1549 ERR("bd_addr is NULL");
1550 return BT_STATUS_PARM_INVALID;
1553 adapter_proxy = _bt_hal_get_adapter_proxy();
1554 if (!adapter_proxy) {
1555 ERR("Could not get Adapter Proxy");
1556 return BT_STATUS_FAIL;
1559 conn = _bt_hal_get_system_gconn();
1561 ERR("_bt_hal_get_system_gconn failed");
1562 return BT_STATUS_FAIL;
1565 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1566 INFO("Address: %s: profile: %d", address, profile);
1568 device_path = _bt_hal_get_device_object_path(address);
1569 if (device_path == NULL) {
1570 ERR("No paired device");
1571 return BT_STATUS_FAIL;
1574 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1575 NULL, BT_HAL_BLUEZ_NAME, device_path,
1576 BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
1577 g_free(device_path);
1578 if (!device_proxy) {
1579 ERR("Error creating device_proxy");
1580 return BT_STATUS_FAIL;
1583 result = g_dbus_proxy_call_sync(device_proxy, "Get",
1584 g_variant_new("(ss)", BT_HAL_DEVICE_INTERFACE, "TrustedProfiles"),
1585 G_DBUS_CALL_FLAGS_NONE, -1,
1587 g_object_unref(device_proxy);
1589 ERR("Failed to get trusted profile, Error occured in proxy call");
1590 if (error != NULL) {
1591 ERR("(Error: %s)", error->message);
1592 g_clear_error(&error);
1595 return BT_STATUS_FAIL;
1598 g_variant_get(result, "(v)", &temp);
1599 trusted_flag = g_variant_get_uint32(temp);
1600 DBG("TRUST_FLAG 0x%X", trusted_flag);
1601 g_variant_unref(temp);
1602 g_variant_unref(result);
1604 return __hal_get_trusted_value_from_flag(profile,
1605 trusted_flag, trusted);
1608 int _bt_hal_device_enable_rssi_monitoring(bt_bdaddr_t *bd_addr, uint32_t link_type,
1609 int low_threshold, int in_range_threshold, int high_threshold)
1611 char address[BT_HAL_ADDRESS_STRING_SIZE];
1612 GDBusProxy *adapter_proxy;
1613 GError *error = NULL;
1619 ERR("bd_addr is NULL");
1620 return BT_STATUS_PARM_INVALID;
1623 adapter_proxy = _bt_hal_get_adapter_proxy();
1624 if (!adapter_proxy) {
1625 ERR("Could not get Adapter Proxy");
1626 return BT_STATUS_FAIL;
1629 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1630 INFO("Address: %s: link_type: %d", address, link_type);
1632 result = g_dbus_proxy_call_sync(adapter_proxy, "EnableRssi",
1633 g_variant_new("(siiii)", address, link_type,
1634 low_threshold, in_range_threshold, high_threshold),
1635 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1637 ERR("Proxy call to GetRssiStrength failed");
1639 ERR("Dbus Call Error:[%s]", error->message);
1640 g_error_free(error);
1642 return BT_STATUS_FAIL;
1645 g_variant_unref(result);
1648 return BT_STATUS_SUCCESS;
1651 int _bt_hal_device_get_connected_link_rssi_strength(const bt_bdaddr_t *bd_addr, uint32_t link_type)
1653 char address[BT_HAL_ADDRESS_STRING_SIZE];
1654 GDBusProxy *adapter_proxy;
1655 GError *error = NULL;
1661 ERR("bd_addr is NULL");
1662 return BT_STATUS_PARM_INVALID;
1665 adapter_proxy = _bt_hal_get_adapter_proxy();
1666 if (!adapter_proxy) {
1667 ERR("Could not get Adapter Proxy");
1668 return BT_STATUS_FAIL;
1671 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1672 INFO("Address: %s: link_type: %d", address, link_type);
1674 result = g_dbus_proxy_call_sync(adapter_proxy, "GetRssiStrength",
1675 g_variant_new("(si)", address, link_type),
1676 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1678 ERR("Proxy call to GetRssiStrength failed");
1680 ERR("Dbus Call Error:[%s]", error->message);
1681 g_error_free(error);
1683 return BT_STATUS_FAIL;
1686 g_variant_unref(result);
1689 return BT_STATUS_SUCCESS;
1693 int _bt_hal_device_disconnect(const bt_bdaddr_t *bd_addr)
1696 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
1697 GError *error = NULL;
1698 GVariant *result = NULL;
1699 GDBusConnection *conn;
1700 char *device_path = NULL;
1703 conn = _bt_hal_get_system_gconn();
1705 DBG("Could not get DBUS connection!");
1706 return BT_STATUS_FAIL;
1709 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1710 device_path = _bt_hal_get_device_object_path(address);
1712 if (device_path == NULL) {
1713 ERR("No created device with address:[%s] in statck", address);
1714 return BT_STATUS_FAIL;
1716 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1717 NULL, BT_HAL_BLUEZ_NAME,
1718 device_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1720 g_free(device_path);
1721 if (proxy == NULL) {
1722 ERR("Could not get Device Proxy");
1723 return BT_STATUS_FAIL;
1726 result = g_dbus_proxy_call_sync(proxy, "Disconnect",
1728 G_DBUS_CALL_FLAGS_NONE,
1732 if (error != NULL) {
1733 ERR("Dbus Call Error:[%s]", error->message);
1734 g_clear_error(&error);
1735 g_object_unref(proxy);
1736 return BT_STATUS_FAIL;
1739 g_object_unref(proxy);
1741 g_variant_unref(result);
1744 return BT_STATUS_SUCCESS;