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));
78 DBG("Transport [0x%x] Add [%02x:%02x:%02x:%02x:%02x:%02x]",
79 transport, bd_addr->address[0], bd_addr->address[1],
80 bd_addr->address[2], bd_addr->address[3],
81 bd_addr->address[4], bd_addr->address[5]);
82 conn = _bt_hal_get_system_gconn();
84 ERR("Could not get DBUS connection!");
85 return BT_STATUS_FAIL;
88 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
89 device_path = _bt_hal_get_device_object_path(address);
91 if (device_path == NULL) {
92 ERR("No searched device, attempt to create device");
94 adapter_proxy = _bt_hal_get_adapter_proxy();
96 ERR("Could not get Adapter Proxy");
97 return BT_STATUS_FAIL;
100 ret = g_dbus_proxy_call_sync(adapter_proxy, "CreateDevice",
101 g_variant_new("(s)", address),
102 G_DBUS_CALL_FLAGS_NONE,
108 ERR("CreateDevice Fail: %s", error->message);
109 g_clear_error(&error);
112 g_variant_unref(ret);
113 device_path = _bt_hal_get_device_object_path(address);
115 if (device_path == NULL) {
116 ERR("Device path is still not created!!");
117 return BT_STATUS_FAIL;
119 DBG("Device_path is created[%s]", device_path);
122 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
123 NULL, BT_HAL_BLUEZ_NAME,
124 device_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
128 ERR("Could not get Device Proxy");
129 return BT_STATUS_FAIL;
132 g_dbus_proxy_call(proxy, "Pair",
133 g_variant_new("(y)", transport),
134 G_DBUS_CALL_FLAGS_NONE,
135 BT_HAL_MAX_DBUS_TIMEOUT,
137 (GAsyncReadyCallback)__bt_hal_bond_device_cb,
140 /* Prepare to send Bonding event event to HAL bluetooth */
141 ev.status = BT_STATUS_SUCCESS;
142 ev.state = BT_BOND_STATE_BONDING;
144 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
147 event_cb = _bt_hal_get_stack_message_handler();
149 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
150 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
153 return BT_STATUS_SUCCESS;
156 int _bt_hal_device_remove_bond(const bt_bdaddr_t *bd_addr)
158 char *device_path = NULL;
159 GDBusProxy *adapter_proxy = NULL;
160 GDBusProxy *device_proxy = NULL;
161 GDBusConnection *conn;
162 GError *error = NULL;
163 GVariant *ret = NULL;
164 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
165 GVariant *value = NULL;
166 gboolean is_paired = FALSE;
168 DBG("Add [%02x:%02x:%02x:%02x:%02x:%02x]",
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_NOT_PAIRED;
191 conn = _bt_hal_get_system_gconn();
195 return BT_STATUS_FAIL;
198 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
199 NULL, BT_HAL_BLUEZ_NAME,
200 device_path, BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
201 if (device_proxy != NULL) {
202 ret = g_dbus_proxy_call_sync(device_proxy, "Get",
203 g_variant_new("(ss)", BT_HAL_DEVICE_INTERFACE, "Paired"),
204 G_DBUS_CALL_FLAGS_NONE,
208 g_object_unref(device_proxy);
210 ERR("Getting property failed: [%s]\n", error->message);
212 return BT_STATUS_FAIL;
215 ERR("No paired device");
216 return BT_STATUS_NOT_PAIRED;
219 g_variant_get(ret, "(v)", &value);
220 is_paired = g_variant_get_boolean(value);
221 DBG("is_paired = %d", is_paired);
222 g_variant_unref(value);
223 g_variant_unref(ret);
227 if (is_paired == FALSE) {
228 ERR("No paired device");
229 return BT_STATUS_NOT_PAIRED;
232 g_dbus_proxy_call(adapter_proxy, "UnpairDevice",
233 g_variant_new("(o)", device_path),
234 G_DBUS_CALL_FLAGS_NONE,
235 BT_HAL_MAX_DBUS_TIMEOUT,
237 (GAsyncReadyCallback)__bt_hal_unbond_device_cb,
238 (gpointer)device_path);
240 return BT_STATUS_SUCCESS;
243 int _bt_hal_device_cancel_bond(const bt_bdaddr_t *bd_addr)
245 int result = BT_STATUS_SUCCESS;
248 result = _bt_hal_agent_reply_cancellation();
249 if (result != BT_HAL_ERROR_NONE) {
250 ERR("Fail to call reply cancellation");
251 return BT_STATUS_FAIL;
254 _bt_hal_agent_set_canceled(TRUE);
258 int _bt_hal_device_legacy_pin_reply(const bt_bdaddr_t *bd_addr,
259 gboolean accept, uint8_t pin_len, char *pincode)
261 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
265 return BT_STATUS_FAIL;
267 DBG("pin_len [0x%x]", pin_len);
268 DBG("pincode [%s]", pincode);
271 gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, pincode, NULL);
273 gap_agent_reply_pin_code(agent, GAP_AGENT_REJECT, NULL, NULL);
276 return BT_STATUS_SUCCESS;
279 int _bt_hal_device_ssp_reply(const bt_bdaddr_t *bd_addr, bt_ssp_variant_t variant,
280 uint8_t accept, uint32_t passkey)
282 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
286 return BT_STATUS_FAIL;
289 case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
290 DBG("SSP: PASSKEY_CONFIRMATION");
292 gap_agent_reply_confirmation(agent, GAP_AGENT_ACCEPT, NULL);
294 gap_agent_reply_confirmation(agent, GAP_AGENT_REJECT, NULL);
296 case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
297 DBG("SSP: PASSKEY_NOTIFICATION");
299 case BT_SSP_VARIANT_PASSKEY_ENTRY:
300 DBG("SSP: PASSKEY_ENTRY");
303 snprintf(str_passkey, sizeof(str_passkey), "%.6d", passkey);
304 DBG("Passkey [%s]", str_passkey);
305 gap_agent_reply_passkey(agent, GAP_AGENT_ACCEPT, str_passkey, NULL);
307 gap_agent_reply_passkey(agent, GAP_AGENT_REJECT, NULL, NULL);
309 case BT_SSP_VARIANT_CONSENT:
310 DBG("SSP: VARIANT_CONSENT: Unhandled!");
317 return BT_STATUS_SUCCESS;
320 int _bt_hal_dbus_get_remote_device_services(const bt_bdaddr_t *remote_addr)
322 char *device_path = NULL;
323 GDBusProxy *device_proxy = NULL;
324 GDBusConnection *conn;
325 GDBusProxy *adapter_proxy;
326 //char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
327 char *address = NULL;
328 int result = BT_STATUS_SUCCESS;
331 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
333 _bt_hal_convert_addr_type_to_string(address, remote_addr->address);
335 if (remote_addr == NULL) {
336 result = BT_STATUS_PARM_INVALID;
340 adapter_proxy = _bt_hal_get_adapter_proxy();
341 if (adapter_proxy == NULL) {
342 result = BT_STATUS_FAIL;
346 conn = _bt_hal_get_system_gconn();
348 ERR("Could not get System DBUS Connection");
349 result = BT_STATUS_FAIL;
353 device_path = _bt_hal_get_device_object_path(address);
355 if (device_path == NULL) {
356 ERR("Remote device is not paired..can not perform SDP!!!");
357 result = BT_STATUS_FAIL;
361 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
362 NULL, BT_HAL_BLUEZ_NAME,
363 device_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
366 if (device_proxy == NULL) {
367 ERR("Could not create Device Proxy");
368 result = BT_STATUS_FAIL;
372 g_dbus_proxy_call(device_proxy, "DiscoverServices",
373 g_variant_new("(s)", ""),
374 G_DBUS_CALL_FLAGS_NONE,
375 BT_HAL_MAX_DBUS_TIMEOUT,
377 (GAsyncReadyCallback)__bt_hal_device_service_search_cb,
380 return BT_STATUS_SUCCESS;
387 int _bt_hal_device_authorize_response(const bt_bdaddr_t *bd_addr, bt_service_id_t service_id,
388 uint8_t authorize, uint8_t save_settings)
390 int reply = GAP_AGENT_ACCEPT;
391 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
395 return BT_STATUS_FAIL;
398 reply = GAP_AGENT_REJECT;
399 else if (authorize && save_settings)
400 reply = GAP_AGENT_ACCEPT_ALWAYS;
402 gap_agent_reply_authorize(agent, reply, NULL);
405 return BT_STATUS_SUCCESS;
408 int _bt_hal_device_set_trust(const bt_bdaddr_t *bd_addr, uint8_t trust)
410 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
411 gchar *device_path = NULL;
412 GDBusProxy *device_proxy;
413 gboolean previous_value;
415 GDBusConnection *conn;
416 GError *error = NULL;
417 GVariant *result = NULL;
418 GVariant *temp = NULL;
419 int ret = BT_STATUS_SUCCESS;
423 return BT_STATUS_PARM_INVALID;
430 conn = _bt_hal_get_system_gconn();
433 ERR("Failed to get DBUS connection");
434 return BT_STATUS_FAIL;
437 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
439 device_path = _bt_hal_get_device_object_path(address);
441 if (device_path == NULL) {
442 ERR("No paired device");
443 return BT_STATUS_FAIL;
446 DBG("Device path [%s]", device_path);
447 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
448 NULL, BT_HAL_BLUEZ_NAME,
449 device_path, BT_HAL_PROPERTIES_INTERFACE, NULL, &error);
453 if (device_proxy == NULL) {
455 g_dbus_error_strip_remote_error(error);
456 ERR("Device proxy get failed %s", error->message);
459 ERR("Failed to get Device Proxy");
460 return BT_STATUS_FAIL;
463 result = g_dbus_proxy_call_sync(device_proxy, "Get",
464 g_variant_new("(ss)", BT_HAL_DEVICE_INTERFACE, "Trusted"),
465 G_DBUS_CALL_FLAGS_NONE,
471 ERR("Getting property failed: [%s]\n", error->message);
473 g_object_unref(device_proxy);
474 return BT_STATUS_FAIL;
478 g_variant_get(result, "(v)", &temp);
479 previous_value = g_variant_get_boolean(temp);
480 DBG("Previous value [%d]", previous_value);
482 /* If the input is same with previous value, return error. */
483 if (previous_value == authorize) {
484 ERR("Same value: %d", previous_value);
485 g_object_unref(device_proxy);
486 g_object_unref(result);
487 g_object_unref(temp);
488 return BT_STATUS_PARM_INVALID;
491 DBG("Set authotrize [%d]", authorize);
492 result = g_dbus_proxy_call_sync(device_proxy, "Set",
493 g_variant_new("(ssv)", BT_HAL_DEVICE_INTERFACE, "Trusted", g_variant_new("b", authorize)),
494 G_DBUS_CALL_FLAGS_NONE,
500 ERR("SetProperty error: [%s]", error->message);
502 ret = BT_STATUS_FAIL;
505 g_object_unref(device_proxy);
508 g_object_unref(result);
510 g_object_unref(temp);
516 static void __bt_hal_device_service_search_cb(GDBusProxy *proxy, GAsyncResult *res,
519 /* Buffer and propety count management */
520 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
521 struct hal_ev_remote_device_props *ev = (void*) buf;;
525 int result = BT_HAL_ERROR_NONE;
526 char *address = (char*) user_data;
529 g_dbus_proxy_call_finish(proxy, res, &err);
530 g_object_unref(proxy);
532 /* Check event pointer */
534 event_cb = _bt_hal_get_stack_message_handler();
536 ERR("event_cb is NULL, can not send Service search results to HAL User");
541 g_dbus_error_strip_remote_error(err);
542 ERR("Error occured in Proxy call [%s]\n", err->message);
544 if (g_strrstr("Operation canceled", err->message))
545 result = BT_HAL_ERROR_CANCEL_BY_USER;
546 else if (g_strrstr("In Progress", err->message))
547 result = BT_HAL_ERROR_IN_PROGRESS;
548 else if (g_strrstr("Host is down", err->message))
549 result = BT_HAL_ERROR_HOST_DOWN;
551 result = BT_HAL_ERROR_CONNECTION_ERROR;
554 if (result == BT_HAL_ERROR_HOST_DOWN ||
555 result == BT_HAL_ERROR_CONNECTION_ERROR) {
556 ERR("Service search has failed due to Host Down or connection error, attempt to find properties");
557 if (__bt_hal_dbus_enquire_remote_device_services(address) == BT_STATUS_SUCCESS)
564 DBG("SDP is successful..lets fetch the device properties..");
565 if (__bt_hal_dbus_enquire_remote_device_services(address) == BT_STATUS_SUCCESS)
568 ev->status = BT_STATUS_FAIL;
571 ERR("Error: Failed to get Remote device properties after SDP,"
572 " Num Prop [%d] total size [%zd]", ev->num_props, size);
573 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
581 static void __bt_device_parse_services(GVariant *result)
583 /* Buffer and propety count management */
584 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
585 struct hal_ev_remote_device_props *ev = (void*) buf;;
588 GVariantIter *property_iter;
592 const gchar *address = NULL;
594 memset(buf, 0, sizeof(buf));
597 ev->status = BT_STATUS_SUCCESS;
599 g_variant_get(result, "(a{sv})", &property_iter);
600 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
601 if (!g_strcmp0(key, "Address")) {
602 address = g_variant_get_string(value, NULL);
603 DBG("Address [%s]", address);
604 _bt_hal_convert_addr_string_to_type(ev->bdaddr, address);
605 } else if (!g_strcmp0(key, "UUIDs")) {
610 size1 = g_variant_get_size(value);
611 int num_props_tmp = ev->num_props;
613 uuid_value = (char **)g_variant_get_strv(value, &size1);
614 for (i = 0; uuid_value[i] != NULL; i++)
616 /* UUID collection */
617 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
618 for (i = 0; uuid_value[i] != NULL; i++) {
619 char *uuid_str = NULL;
620 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
621 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
622 uuid_str = g_strdup(uuid_value[i]);
623 DBG("UUID string [%s]\n", uuid_str);
624 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
625 memcpy(uuids + i * BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
628 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
629 (BT_HAL_STACK_UUID_SIZE * uuid_count), uuids);
630 ev->num_props = num_props_tmp + 1;
634 ERR("Unhandled Property:[%s]", key);
638 DBG("Send Remote Device services to HAL,"
639 " Num Prop [%d] total size [%zd]", ev->num_props, size);
640 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
642 g_variant_unref(result);
643 g_variant_iter_free(property_iter);
646 int __bt_hal_dbus_enquire_remote_device_services(char *address)
648 char *device_path = NULL;
649 GError *error = NULL;
650 GDBusProxy *device_proxy;
651 GDBusConnection *conn;
654 device_path = _bt_hal_get_device_object_path(address);
656 ERR("Device not paired");
657 return BT_STATUS_FAIL;
660 conn = _bt_hal_get_system_gconn();
663 ERR("_bt_hal_get_system_gconn failed");
664 return BT_STATUS_FAIL;
667 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
671 BT_HAL_PROPERTIES_INTERFACE,
675 ERR("Error creating device_proxy");
677 return BT_STATUS_FAIL;
680 result = g_dbus_proxy_call_sync(device_proxy,
682 g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
683 G_DBUS_CALL_FLAGS_NONE,
689 ERR("Error occured in Proxy call");
691 ERR("Error occured in Proxy call (Error: %s)", error->message);
692 g_clear_error(&error);
694 g_object_unref(device_proxy);
696 return BT_STATUS_FAIL;
699 g_object_unref(device_proxy);
702 /* Fetch Device Services and send to HAL User */
703 __bt_device_parse_services(result);
706 return BT_STATUS_SUCCESS;
709 static void __bt_hal_bond_device_cb(GDBusProxy *proxy, GAsyncResult *res,
713 const char *device_path;
714 int result = BT_STATUS_SUCCESS;
715 struct hal_ev_bond_state_changed ev;
716 memset(&ev, 0, sizeof(ev));
717 char dev_address[18];
720 /* Terminate ALL system popup */
722 if (headed_plugin_info->plugin_headed_enabled)
723 headed_plugin_info->headed_plugin->bt_destroy_popup_all();
727 g_dbus_proxy_call_finish(proxy, res, &err);
728 device_path = g_dbus_proxy_get_object_path(proxy);
729 _bt_hal_convert_device_path_to_address(device_path, dev_address);
730 g_object_unref(proxy);
733 g_dbus_error_strip_remote_error(err);
734 ERR("@@@Error occured in CreateBonding [%s]", err->message);
735 if (g_strrstr(err->message, "Already Exists")) {
736 ERR("Bond Already exists");
737 result = BT_STATUS_ALREADY_CONNECT;
738 } else if (g_strrstr(err->message, "Authentication Rejected")) {
740 result = BT_STATUS_AUTH_REJECTED;
741 } else if (_bt_hal_agent_is_canceled() ||
742 g_strrstr(err->message, "Authentication Canceled")) {
743 INFO("Cancelled by USER");
744 result = BT_STATUS_AUTH_FAILURE;
745 } else if (g_strrstr(err->message, "In Progress")) {
746 INFO("Bond in progress, cancel and retry");
747 } else if (g_strrstr(err->message, "Authentication Failed")) {
748 INFO("Authentication Failed");
749 result = BT_STATUS_AUTH_FAILURE;
750 } else if (g_strrstr(err->message, "Page Timeout")) {
751 INFO("Page Timeout");
752 /* This is the special case
753 As soon as call bluetooth_bond_device, try to cancel bonding.
754 In this case, before completing to call 'CreatePairedDevice' method
755 the procedure is stopped. So 'Cancle' error is not return.
757 result = BT_STATUS_RMT_DEV_DOWN;
758 } else if (g_strrstr(err->message, BT_HAL_TIMEOUT_MESSAGE)) {
760 result = BT_STATUS_FAIL;
761 } else if (g_strrstr(err->message, "Connection Timeout")) {
762 /* Pairing request timeout */
763 result = BT_STATUS_RMT_DEV_DOWN;
764 } else if (g_strrstr(err->message, "Authentication Timeout")) {
765 /* Pairing request timeout */
766 result = BT_STATUS_AUTH_FAILURE;
768 DBG("Default case: Pairing failed");
769 result = BT_STATUS_AUTH_FAILURE;
773 if (result != BT_STATUS_SUCCESS) {
774 DBG("Bonding Failed!!");
776 /* Prepare to send event to HAL bluetooth */
778 ev.state = BT_BOND_STATE_NONE;
780 _bt_hal_convert_addr_string_to_type(ev.bdaddr, dev_address);
783 event_cb = _bt_hal_get_stack_message_handler();
785 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
786 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
789 DBG("Bonding Success!! [%s]", dev_address);
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));
804 g_dbus_proxy_call_finish(proxy, res, &err);
806 ERR("Error occured in RemoveBonding [%s]\n", err->message);
807 result = BT_STATUS_FAIL;
811 device_path = (char *)user_data;
812 if (result != BT_STATUS_SUCCESS) {
813 /* Prepare to send event to HAL bluetooth */
815 ev.state = BT_BOND_STATE_NONE;
817 _bt_hal_convert_device_path_to_address(device_path, dev_address);
818 _bt_hal_convert_addr_string_to_type(ev.bdaddr, dev_address);
821 event_cb = _bt_hal_get_stack_message_handler();
823 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
824 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
830 static gboolean __bt_device_bonded_device_info_cb(gpointer user_data)
832 /* Buffer and propety count management */
833 uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
834 struct hal_ev_remote_device_props *ev = (void*) buf;;
837 GVariant *result = user_data;
838 GVariantIter *property_iter;
839 GVariantIter *char_value_iter;
841 const gchar *address = NULL;
842 const gchar *name = NULL;
843 unsigned int cod = 0;
848 GByteArray *manufacturer_data = NULL;
852 unsigned int data_len = 0;
853 uint8_t is_alias_set;
855 memset(buf, 0, sizeof(buf));
858 ev->status = BT_STATUS_SUCCESS;
860 g_variant_get(result, "(a{sv})", &property_iter);
861 while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
862 if (!g_strcmp0(key, "Address")) {
863 address = g_variant_get_string(value, NULL);
864 DBG("Address [%s]", address);
865 _bt_hal_convert_addr_string_to_type(ev->bdaddr, address);
866 } else if (!g_strcmp0(key, "Alias")) {
867 name = g_variant_get_string(value, NULL);
868 DBG("Alias [%s]", name);
869 size += __bt_insert_hal_properties(buf + size,
870 HAL_PROP_DEVICE_FRIENDLY_NAME, strlen(name) + 1, name);
872 } else if (!g_strcmp0(key, "Class")) {
873 cod = g_variant_get_uint32(value);
874 DBG("Class [%d]", cod);
875 size += __bt_insert_hal_properties(buf + size,
876 HAL_PROP_DEVICE_CLASS, sizeof(unsigned int), &cod);
878 } else if (!g_strcmp0(key, "Connected")) {
879 connected = g_variant_get_byte(value);
880 DBG("Connected [%d]", connected);
881 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
882 sizeof(unsigned int), &connected);
884 } else if (!g_strcmp0(key, "Paired")) {
885 paired = (g_variant_get_boolean(value) ? 1 : 0);
886 DBG("Paired [%d]", paired);
887 size += __bt_insert_hal_properties(buf + size,
888 HAL_PROP_DEVICE_PAIRED, sizeof(uint8_t), &paired);
890 } else if (!g_strcmp0(key, "Trusted")) {
891 trust = (g_variant_get_boolean(value) ? 1 : 0);
892 DBG("Trusted [%d]", trust);
893 size += __bt_insert_hal_properties(buf + size,
894 HAL_PROP_DEVICE_TRUSTED, sizeof(uint8_t), &trust);
896 } else if (!g_strcmp0(key, "Name")) {
897 name = g_variant_get_string(value, NULL);
898 DBG("Name [%s]", name);
899 size += __bt_insert_hal_properties(buf + size,
900 HAL_PROP_DEVICE_NAME, strlen(name) + 1, name);
902 } else if (!g_strcmp0(key, "RSSI")) {
903 rssi = g_variant_get_int16(value);
904 DBG("RSSI [%d]", rssi);
905 size += __bt_insert_hal_properties(buf + size,
906 HAL_PROP_DEVICE_RSSI, sizeof(unsigned int), &rssi);
908 } else if (!g_strcmp0(key, "UUIDs")) {
913 size1 = g_variant_get_size(value);
914 int num_props_tmp = ev->num_props;
916 uuid_value = (char **)g_variant_get_strv(value, &size1);
917 for (i = 0; uuid_value[i] != NULL; i++)
919 /* UUID collection */
920 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
921 for (i = 0; uuid_value[i] != NULL; i++) {
922 char *uuid_str = NULL;
923 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
924 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
925 uuid_str = g_strdup(uuid_value[i]);
926 DBG("[%d] [%s]", i, uuid_str);
927 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
928 memcpy(uuids + i * BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
931 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
932 (BT_HAL_STACK_UUID_SIZE * uuid_count), uuids);
933 ev->num_props = num_props_tmp + 1;
936 } else if (!g_strcmp0(key, "LegacyManufacturerDataLen")) {
937 data_len = g_variant_get_uint16(value);
938 DBG("LegacyManufacturerDataLen [%d]", data_len);
939 } else if (!g_strcmp0(key, "LegacyManufacturerData")) {
940 manufacturer_data = g_byte_array_new();
941 g_variant_get(value, "ay", &char_value_iter);
942 while (g_variant_iter_loop(char_value_iter, "y", &char_value))
943 g_byte_array_append(manufacturer_data, &char_value, 1);
945 g_variant_iter_free(char_value_iter);
947 if (manufacturer_data) {
948 if (manufacturer_data->len > 0) {
949 size += __bt_insert_hal_properties(
950 buf + size, HAL_PROP_DEVICE_BLE_ADV_DATA,
951 manufacturer_data->len, manufacturer_data->data);
955 g_byte_array_free(manufacturer_data, FALSE);
956 } else if (!g_strcmp0(key, "IsAliasSet")) {
957 is_alias_set = (g_variant_get_boolean(value) ? 1 : 0);
958 DBG("IsAliasSet: %s", ((is_alias_set == 1) ? "TRUE" : "FALSE"));
959 size += __bt_insert_hal_properties(buf + size,
960 HAL_PROP_DEVICE_IS_ALIAS_SET, sizeof(uint8_t), &is_alias_set);
963 DBG("Unhandled Property:[%s]", key);
968 event_cb = _bt_hal_get_stack_message_handler();
970 ERR("event_cb is NULL");
974 if ((paired == 0) && (trust == 0)) {
975 ev->status = BT_STATUS_FAIL;
978 DBG("Send Remote Device properties event to HAL,"
979 " Num Prop [%d] total size [%zd]", ev->num_props, size);
980 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
983 DBG("Send Remote Device properties event to HAL,"
984 " Num Prop [%d] total size [%zd]", ev->num_props, size);
985 event_cb(HAL_EV_REMOTE_DEVICE_PROPS, (void*) buf, size);
990 g_variant_unref(result);
991 g_variant_iter_free(property_iter);
995 int _bt_hal_dbus_get_remote_device_properties(bt_bdaddr_t *remote_addr)
997 char *device_path = NULL;
998 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
999 GError *error = NULL;
1000 GDBusProxy *device_proxy;
1001 GDBusConnection *conn;
1005 ERR("Invalid device address ptr received");
1006 return BT_STATUS_PARM_INVALID;
1009 _bt_hal_convert_addr_type_to_string(address, remote_addr->address);
1010 device_path = _bt_hal_get_device_object_path(address);
1012 ERR("Device not paired");
1013 return BT_STATUS_FAIL;
1016 conn = _bt_hal_get_system_gconn();
1018 g_free(device_path);
1019 ERR("_bt_hal_get_system_gconn failed");
1020 return BT_STATUS_FAIL;
1023 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1027 BT_HAL_PROPERTIES_INTERFACE,
1030 if (!device_proxy) {
1031 ERR("Error creating device_proxy");
1032 g_free(device_path);
1033 return BT_STATUS_FAIL;
1036 result = g_dbus_proxy_call_sync(device_proxy,
1038 g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
1039 G_DBUS_CALL_FLAGS_NONE,
1045 ERR("Error occured in Proxy call");
1046 if (error != NULL) {
1047 ERR("Error occured in Proxy call (Error: %s)", error->message);
1048 g_clear_error(&error);
1050 g_object_unref(device_proxy);
1051 g_free(device_path);
1052 return BT_STATUS_FAIL;
1055 g_object_unref(device_proxy);
1056 g_free(device_path);
1058 * As we need to provide async callback to user from HAL, simply schedule a
1059 * callback method which will carry actual result
1061 g_idle_add(__bt_device_bonded_device_info_cb, (gpointer)result);
1063 return BT_STATUS_SUCCESS;
1066 static int __bt_hal_dbus_set_remote_device_alias(bt_bdaddr_t *remote_addr, char *alias)
1068 char address[BT_HAL_ADDRESS_STRING_SIZE];
1069 gchar *device_path = NULL;
1070 GDBusProxy *adapter_proxy;
1071 GDBusProxy *device_proxy;
1072 GError *error = NULL;
1073 GDBusConnection *conn;
1076 adapter_proxy = _bt_hal_get_adapter_proxy();
1077 if (!adapter_proxy) {
1078 ERR("Could not get Adapter Proxy");
1079 return BT_STATUS_FAIL;
1082 conn = _bt_hal_get_system_gconn();
1084 ERR("_bt_hal_get_system_gconn failed");
1085 return BT_STATUS_FAIL;
1088 _bt_hal_convert_addr_type_to_string(address, remote_addr->address);
1089 INFO("Address: %s, Alias: %s", address, alias);
1091 device_path = _bt_hal_get_device_object_path(address);
1092 if (device_path == NULL) {
1093 ERR("No paired device");
1094 return BT_STATUS_FAIL;
1097 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1098 NULL, BT_HAL_BLUEZ_NAME, device_path,
1099 BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
1100 g_free(device_path);
1101 if (!device_proxy) {
1102 ERR("Error creating device_proxy");
1103 return BT_STATUS_FAIL;
1106 result = g_dbus_proxy_call_sync(device_proxy, "Set",
1107 g_variant_new("(ssv)",
1108 BT_HAL_DEVICE_INTERFACE,
1109 "Alias", g_variant_new("s", alias)),
1110 G_DBUS_CALL_FLAGS_NONE,
1114 g_object_unref(device_proxy);
1116 ERR("Error occured in Proxy call");
1117 if (error != NULL) {
1118 ERR("Error occured in Proxy call (Error: %s)", error->message);
1119 g_clear_error(&error);
1121 return BT_STATUS_FAIL;
1123 g_variant_unref(result);
1125 return BT_STATUS_SUCCESS;
1128 /* Set Remote Device Properties */
1129 int _bt_hal_dbus_set_remote_device_property(
1130 bt_bdaddr_t *remote_addr, const bt_property_t *property)
1134 if (remote_addr == NULL) {
1135 ERR("Invalid parameters received");
1136 return BT_STATUS_PARM_INVALID;
1139 if (property == NULL || property->val == NULL) {
1140 ERR("Invalid parameters received");
1141 return BT_STATUS_PARM_INVALID;
1144 switch (property->type) {
1145 case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
1146 result = __bt_hal_dbus_set_remote_device_alias(
1147 remote_addr, (char *) property->val);
1150 result = BT_STATUS_UNSUPPORTED;
1153 DBG("Result [%d]", result);
1157 int _bt_hal_device_get_connection_state(const bt_bdaddr_t *bd_addr)
1159 char address[BT_HAL_ADDRESS_STRING_SIZE];
1160 gchar *device_path = NULL;
1161 GDBusProxy *adapter_proxy;
1162 GDBusProxy *device_proxy;
1163 GError *error = NULL;
1164 GDBusConnection *conn;
1166 GVariant *tmp_value = NULL;
1167 GVariant *value = NULL;
1168 gboolean is_connected = FALSE;
1171 ERR("bd_addr is NULL");
1175 adapter_proxy = _bt_hal_get_adapter_proxy();
1176 if (!adapter_proxy) {
1177 ERR("Could not get Adapter Proxy");
1181 conn = _bt_hal_get_system_gconn();
1183 ERR("_bt_hal_get_system_gconn failed");
1187 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1188 DBG("Address: %s", address);
1190 device_path = _bt_hal_get_device_object_path(address);
1191 if (device_path == NULL) {
1192 ERR("No paired device");
1196 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1197 NULL, BT_HAL_BLUEZ_NAME, device_path,
1198 BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
1199 g_free(device_path);
1200 if (!device_proxy) {
1201 ERR("Error creating device_proxy");
1205 result = g_dbus_proxy_call_sync(device_proxy, "GetProperties",
1206 g_variant_new("(s)", address),
1207 G_DBUS_CALL_FLAGS_NONE,
1211 g_object_unref(device_proxy);
1213 ERR("Error occured in Proxy call");
1214 if (error != NULL) {
1215 ERR("Error occured in Proxy call (Error: %s)", error->message);
1216 g_clear_error(&error);
1221 g_variant_get(result , "(@a{sv})", &value);
1222 g_variant_unref(result);
1225 tmp_value = g_variant_lookup_value(value,
1227 G_VARIANT_TYPE_BOOLEAN);
1229 is_connected = g_variant_get_boolean(tmp_value);
1230 g_variant_unref(tmp_value);
1232 g_variant_unref(value);
1242 int _bt_hal_device_get_service_connection_state(
1243 const bt_bdaddr_t *bd_addr, bt_service_id_t rem_svc_id)
1245 char address[BT_HAL_ADDRESS_STRING_SIZE];
1246 gchar *device_path = NULL;
1247 GDBusProxy *adapter_proxy;
1248 GDBusProxy *device_proxy;
1249 GError *error = NULL;
1250 GDBusConnection *conn;
1252 gboolean is_connected;
1256 ERR("bd_addr is NULL");
1260 adapter_proxy = _bt_hal_get_adapter_proxy();
1261 if (!adapter_proxy) {
1262 ERR("Could not get Adapter Proxy");
1266 conn = _bt_hal_get_system_gconn();
1268 ERR("_bt_hal_get_system_gconn failed");
1272 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1273 INFO("Address: %s: Remote svc_id: %d", address + 12, rem_svc_id);
1275 device_path = _bt_hal_get_device_object_path(address);
1276 if (device_path == NULL) {
1277 ERR("No paired device");
1281 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1282 NULL, BT_HAL_BLUEZ_NAME, device_path,
1283 BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1284 g_free(device_path);
1285 if (!device_proxy) {
1286 ERR("Error creating device_proxy");
1290 uuid = _bt_convert_service_id_to_uuid_string(rem_svc_id);
1291 DBG("uuid: %s", uuid);
1293 g_object_unref(device_proxy);
1297 result = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
1298 g_variant_new("(s)", uuid),
1299 G_DBUS_CALL_FLAGS_NONE,
1304 g_object_unref(device_proxy);
1306 ERR("Error occured in Proxy call");
1307 if (error != NULL) {
1308 ERR("Error occured in Proxy call (Error: %s)", error->message);
1309 g_clear_error(&error);
1314 g_variant_get(result, "(b)", &is_connected);
1315 g_variant_unref(result);
1323 int _bt_hal_device_register_osp_server(uint32_t type, char *uuid, char *path, int fd)
1325 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
1326 gboolean result = FALSE;
1330 return BT_STATUS_FAIL;
1332 result = _bt_hal_gap_agent_register_osp_server(agent, type, uuid, path, fd);
1334 return BT_STATUS_FAIL;
1337 return BT_STATUS_SUCCESS;
1340 int _bt_hal_device_unregister_osp_server(uint32_t type, char *uuid)
1342 GapAgentPrivate *agent = _bt_hal_get_adapter_agent();
1343 gboolean result = FALSE;
1347 return BT_STATUS_FAIL;
1349 result = _bt_hal_gap_agent_unregister_osp_server(agent, type, uuid);
1351 return BT_STATUS_FAIL;
1354 return BT_STATUS_SUCCESS;
1357 static char* __bt_hal_get_trusted_profile_uuid(bt_trusted_profile_t profile)
1360 case BT_TRUSTED_PROFILE_PBAP:
1361 return g_strdup("00001130-0000-1000-8000-00805f9b34fb");
1362 case BT_TRUSTED_PROFILE_MAP:
1363 return g_strdup("00001134-0000-1000-8000-00805f9b34fb");
1364 case BT_TRUSTED_PROFILE_SAP:
1365 return g_strdup("0000112D-0000-1000-8000-00805f9b34fb");
1366 case BT_TRUSTED_PROFILE_HFP_HF:
1367 return g_strdup("0000111e-0000-1000-8000-00805f9b34fb");
1368 case BT_TRUSTED_PROFILE_A2DP:
1369 return g_strdup("0000110b-0000-1000-8000-00805f9b34fb");
1370 case BT_TRUSTED_PROFILE_ALL:
1377 int _bt_hal_device_set_trusted_profile(const bt_bdaddr_t *bd_addr,
1378 bt_trusted_profile_t profile, uint8_t trust)
1380 char address[BT_HAL_ADDRESS_STRING_SIZE];
1381 gchar *device_path = NULL;
1382 GDBusProxy *adapter_proxy;
1383 GDBusProxy *device_proxy;
1384 GError *error = NULL;
1385 GDBusConnection *conn;
1391 ERR("bd_addr is NULL");
1392 return BT_STATUS_PARM_INVALID;
1395 adapter_proxy = _bt_hal_get_adapter_proxy();
1396 if (!adapter_proxy) {
1397 ERR("Could not get Adapter Proxy");
1398 return BT_STATUS_FAIL;
1401 conn = _bt_hal_get_system_gconn();
1403 ERR("_bt_hal_get_system_gconn failed");
1404 return BT_STATUS_FAIL;
1407 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1408 INFO("Address: %s: profile: %d, trusted: %d", address + 12, profile, trust);
1410 device_path = _bt_hal_get_device_object_path(address);
1411 if (device_path == NULL) {
1412 ERR("No paired device");
1413 return BT_STATUS_FAIL;
1416 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1417 NULL, BT_HAL_BLUEZ_NAME, device_path,
1418 BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1419 g_free(device_path);
1420 if (!device_proxy) {
1421 ERR("Error creating device_proxy");
1422 return BT_STATUS_FAIL;
1425 uuid = __bt_hal_get_trusted_profile_uuid(profile);
1427 ERR("Not supported");
1428 g_object_unref(device_proxy);
1429 return BT_STATUS_UNSUPPORTED;
1432 trusted = ((trust == 0) ? FALSE : TRUE);
1433 DBG("uuid: %s", uuid);
1434 result = g_dbus_proxy_call_sync(device_proxy, "SetTrustedProfile",
1435 g_variant_new("(sb)", uuid, trusted),
1436 G_DBUS_CALL_FLAGS_NONE,
1439 g_object_unref(device_proxy);
1441 ERR("Failed to Set Profile Trusted, Error occured in proxy call");
1442 if (error != NULL) {
1443 ERR("(Error: %s)", error->message);
1444 g_clear_error(&error);
1446 return BT_STATUS_FAIL;
1449 g_variant_unref(result);
1451 return BT_STATUS_SUCCESS;
1454 static int __hal_get_trusted_value_from_flag(bt_trusted_profile_t profile,
1455 uint32_t trusted_flag, uint32_t *trusted)
1459 case BT_TRUSTED_PROFILE_PBAP:
1460 /* Bit 0 & 1 - for PBAP Supported */
1461 trusted_flag = (trusted_flag >> 0);
1463 if (!(trusted_flag & PROFILE_SUPPORTED))
1464 return BT_STATUS_UNSUPPORTED;
1466 *trusted = trusted_flag & PROFILE_TRUSTED;
1467 DBG("Profile %d, trusted: %s", profile,
1468 ((*trusted == 0) ? "FALSE" : "TRUE"));
1470 case BT_TRUSTED_PROFILE_MAP:
1471 /* Bit 2 & 3 - for MAP Supported */
1472 trusted_flag = (trusted_flag >> 2);
1474 if (!(trusted_flag & PROFILE_SUPPORTED))
1475 return BT_STATUS_UNSUPPORTED;
1477 *trusted = trusted_flag & PROFILE_TRUSTED;
1478 DBG("Profile %d, trusted: %s", profile,
1479 ((*trusted == 0) ? "FALSE" : "TRUE"));
1481 case BT_TRUSTED_PROFILE_SAP:
1482 /* Bit 4 & 5 - for SAP Supported */
1483 trusted_flag = (trusted_flag >> 4);
1485 if (!(trusted_flag & PROFILE_SUPPORTED))
1486 return BT_STATUS_UNSUPPORTED;
1488 *trusted = trusted_flag & PROFILE_TRUSTED;
1489 DBG("Profile %d, trusted: %s", profile,
1490 ((*trusted == 0) ? "FALSE" : "TRUE"));
1492 case BT_TRUSTED_PROFILE_HFP_HF:
1493 /* Bit 6 & 7 - for HFP_HF Supported */
1494 trusted_flag = (trusted_flag >> 6);
1496 if (PROFILE_BLOCKED != (trusted_flag & PROFILE_SUPPORTED))
1499 DBG("Profile %d, trusted: %s", profile,
1500 ((*trusted == 0) ? "FALSE" : "TRUE"));
1502 case BT_TRUSTED_PROFILE_A2DP:
1503 /* Bit 8 & 9 - for A2DP Supported */
1504 trusted_flag = (trusted_flag >> 8);
1506 if (PROFILE_BLOCKED != (trusted_flag & PROFILE_SUPPORTED))
1509 DBG("Profile %d, trusted: %s", profile,
1510 ((*trusted == 0) ? "FALSE" : "TRUE"));
1512 case BT_TRUSTED_PROFILE_ALL:
1513 /* Return Flag for All profiles*/
1514 *trusted = trusted_flag;
1515 return BT_STATUS_SUCCESS;
1517 return BT_STATUS_UNSUPPORTED;
1523 return BT_STATUS_SUCCESS;
1526 int _bt_hal_device_get_trusted_profile(const bt_bdaddr_t *bd_addr,
1527 bt_trusted_profile_t profile, uint32_t *trusted)
1529 char address[BT_HAL_ADDRESS_STRING_SIZE];
1530 gchar *device_path = NULL;
1531 GDBusProxy *adapter_proxy;
1532 GDBusProxy *device_proxy;
1533 GError *error = NULL;
1534 GDBusConnection *conn;
1537 uint32_t trusted_flag;
1540 ERR("bd_addr is NULL");
1541 return BT_STATUS_PARM_INVALID;
1544 adapter_proxy = _bt_hal_get_adapter_proxy();
1545 if (!adapter_proxy) {
1546 ERR("Could not get Adapter Proxy");
1547 return BT_STATUS_FAIL;
1550 conn = _bt_hal_get_system_gconn();
1552 ERR("_bt_hal_get_system_gconn failed");
1553 return BT_STATUS_FAIL;
1556 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1557 INFO("Address: %s: profile: %d", address + 12, profile);
1559 device_path = _bt_hal_get_device_object_path(address);
1560 if (device_path == NULL) {
1561 ERR("No paired device");
1562 return BT_STATUS_FAIL;
1565 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1566 NULL, BT_HAL_BLUEZ_NAME, device_path,
1567 BT_HAL_PROPERTIES_INTERFACE, NULL, NULL);
1568 g_free(device_path);
1569 if (!device_proxy) {
1570 ERR("Error creating device_proxy");
1571 return BT_STATUS_FAIL;
1574 result = g_dbus_proxy_call_sync(device_proxy, "Get",
1575 g_variant_new("(ss)", BT_HAL_DEVICE_INTERFACE, "TrustedProfiles"),
1576 G_DBUS_CALL_FLAGS_NONE, -1,
1578 g_object_unref(device_proxy);
1580 ERR("Failed to get trusted profile, Error occured in proxy call");
1581 if (error != NULL) {
1582 ERR("(Error: %s)", error->message);
1583 g_clear_error(&error);
1586 return BT_STATUS_FAIL;
1589 g_variant_get(result, "(v)", &temp);
1590 trusted_flag = g_variant_get_uint32(temp);
1591 DBG("TRUST_FLAG 0x%X", trusted_flag);
1592 g_variant_unref(temp);
1593 g_variant_unref(result);
1595 return __hal_get_trusted_value_from_flag(profile,
1596 trusted_flag, trusted);
1599 int _bt_hal_device_get_ida(bt_bdaddr_t *bd_addr, bt_bdaddr_t *id_addr)
1601 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
1602 gchar *device_path = NULL;
1603 const gchar *idaddress = NULL;
1604 GDBusProxy *device_proxy;
1605 GError *error = NULL;
1606 GVariant *result = NULL;
1607 GDBusConnection *conn;
1608 int ret = BT_STATUS_SUCCESS;
1610 if (bd_addr == NULL)
1611 return BT_STATUS_PARM_INVALID;
1613 conn = _bt_hal_get_system_gconn();
1616 ERR("_bt_hal_get_system_gconn failed");
1617 return BT_STATUS_FAIL;
1620 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1622 DBG("The device_address is: [%s]", address);
1624 device_path = _bt_hal_get_device_object_path(address);
1627 ERR("_bt_hal_get_device_object_path failed");
1628 return BT_STATUS_FAIL;
1631 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1632 NULL, BT_HAL_BLUEZ_NAME, device_path,
1633 BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1634 g_free(device_path);
1635 if (!device_proxy) {
1636 ERR("Unable to get proxy");
1637 return BT_STATUS_FAIL;
1640 result = g_dbus_proxy_call_sync(device_proxy, "GetIDAddress", NULL,
1641 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1642 if (result == NULL) {
1643 ERR("Failed to get device ID address");
1645 ret = BT_STATUS_FAIL;
1646 if (error != NULL) {
1647 g_dbus_error_strip_remote_error(error);
1648 ERR("Error occured in Proxy call [%s]", error->message);
1649 if (g_strcmp0(error->message, "Does Not Exist") == 0)
1650 ERR("Device does not exist");
1651 g_error_free(error);
1653 g_object_unref(device_proxy);
1657 g_variant_get(result , "(&s)", &idaddress);
1659 DBG_SECURE("ID Address : %s", idaddress);
1660 _bt_hal_convert_addr_string_to_type(id_addr->address, idaddress);
1662 g_variant_unref(result);
1663 g_object_unref(device_proxy);
1668 int _bt_hal_device_enable_rssi_monitoring(bt_bdaddr_t *bd_addr, uint32_t link_type,
1669 int low_threshold, int in_range_threshold, int high_threshold)
1671 char address[BT_HAL_ADDRESS_STRING_SIZE];
1672 GDBusProxy *adapter_proxy;
1673 GError *error = NULL;
1679 ERR("bd_addr is NULL");
1680 return BT_STATUS_PARM_INVALID;
1683 adapter_proxy = _bt_hal_get_adapter_proxy();
1684 if (!adapter_proxy) {
1685 ERR("Could not get Adapter Proxy");
1686 return BT_STATUS_FAIL;
1689 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1690 INFO("Address: %s: link_type: %d", address, link_type);
1692 result = g_dbus_proxy_call_sync(adapter_proxy, "EnableRssi",
1693 g_variant_new("(siiii)", address, link_type,
1694 low_threshold, in_range_threshold, high_threshold),
1695 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1697 ERR("Proxy call to GetRssiStrength failed");
1699 ERR("Dbus Call Error:[%s]", error->message);
1700 g_error_free(error);
1702 return BT_STATUS_FAIL;
1705 g_variant_unref(result);
1708 return BT_STATUS_SUCCESS;
1711 int _bt_hal_device_get_connected_link_rssi_strength(const bt_bdaddr_t *bd_addr, uint32_t link_type)
1713 char address[BT_HAL_ADDRESS_STRING_SIZE];
1714 GDBusProxy *adapter_proxy;
1715 GError *error = NULL;
1721 ERR("bd_addr is NULL");
1722 return BT_STATUS_PARM_INVALID;
1725 adapter_proxy = _bt_hal_get_adapter_proxy();
1726 if (!adapter_proxy) {
1727 ERR("Could not get Adapter Proxy");
1728 return BT_STATUS_FAIL;
1731 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1732 INFO("Address: %s: link_type: %d", address, link_type);
1734 result = g_dbus_proxy_call_sync(adapter_proxy, "GetRssiStrength",
1735 g_variant_new("(si)", address, link_type),
1736 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1738 ERR("Proxy call to GetRssiStrength failed");
1740 ERR("Dbus Call Error:[%s]", error->message);
1741 g_error_free(error);
1743 return BT_STATUS_FAIL;
1746 g_variant_unref(result);
1749 return BT_STATUS_SUCCESS;
1753 int _bt_hal_device_disconnect(const bt_bdaddr_t *bd_addr)
1756 char address[BT_HAL_ADDRESS_STRING_SIZE] = { 0 };
1757 GError *error = NULL;
1758 GVariant *result = NULL;
1759 GDBusConnection *conn;
1760 char *device_path = NULL;
1763 conn = _bt_hal_get_system_gconn();
1765 DBG("Could not get DBUS connection!");
1766 return BT_STATUS_FAIL;
1769 _bt_hal_convert_addr_type_to_string(address, bd_addr->address);
1770 device_path = _bt_hal_get_device_object_path(address);
1772 if (device_path == NULL) {
1773 ERR("No created device with address:[%s] in statck", address);
1774 return BT_STATUS_FAIL;
1776 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1777 NULL, BT_HAL_BLUEZ_NAME,
1778 device_path, BT_HAL_DEVICE_INTERFACE, NULL, NULL);
1780 g_free(device_path);
1781 if (proxy == NULL) {
1782 ERR("Could not get Device Proxy");
1783 return BT_STATUS_FAIL;
1786 result = g_dbus_proxy_call_sync(proxy, "Disconnect",
1788 G_DBUS_CALL_FLAGS_NONE,
1792 if (error != NULL) {
1793 ERR("Dbus Call Error:[%s]", error->message);
1794 g_clear_error(&error);
1795 g_object_unref(proxy);
1796 return BT_STATUS_FAIL;
1799 g_object_unref(proxy);
1801 g_variant_unref(result);
1804 return BT_STATUS_SUCCESS;