2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
22 #if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
23 #include <syspopup_caller.h>
26 #include "bluetooth-api.h"
27 #include "bt-internal-types.h"
29 #include "bt-service-audio.h"
30 #include "bt-service-adapter.h"
31 #include "bt-service-common.h"
32 #include "bt-service-device.h"
33 #include "bt-service-event.h"
34 #include "bt-service-util.h"
36 #include "bt-service-headset-connection.h"
38 #ifdef TIZEN_SUPPORT_DUAL_HF
40 #define VCONF_KEY_BT_HOST_BT_MAC_ADDR "db/wms/host_bt_mac"
47 char device_address[BT_ADDRESS_STRING_SIZE + 1];
48 } bt_connected_headset_data_t;
50 static GList *g_connected_list;
52 static bt_headset_wait_t *g_wait_data;
54 static bt_audio_function_data_t *pdata;
56 static void __bt_remove_device_from_wait_list();
58 static void __bt_free_wait_data();
60 static gboolean __bt_device_support_uuid(char *remote_address,
61 bt_audio_type_t type);
63 static void __bt_hf_request_cb(GDBusProxy *proxy, GAsyncResult *res,
66 GError *g_error = NULL;
67 GVariant *out_param1 = NULL;
68 GVariant *reply = NULL;
69 int result = BLUETOOTH_ERROR_NONE;
70 bt_function_data_t *func_data;
71 request_info_t *req_info;
73 reply = g_dbus_proxy_call_finish(proxy, res, &g_error);
74 g_object_unref(proxy);
76 func_data = user_data;
78 if (func_data == NULL) {
80 BT_ERR("func_data == NULL");
84 req_info = _bt_get_request_info(func_data->req_id);
85 if (req_info == NULL) {
86 BT_ERR("req_info == NULL");
91 BT_ERR("HF Connect Dbus Call Error");
93 BT_ERR("Error: %s\n", g_error->message);
94 g_clear_error(&g_error);
96 result = BLUETOOTH_ERROR_INTERNAL;
98 g_variant_unref(reply);
101 if (req_info->context == NULL)
104 out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
105 func_data->address, BT_ADDRESS_STR_LEN, TRUE, NULL, NULL);
107 g_dbus_method_invocation_return_value(req_info->context,
108 g_variant_new("(iv)", result, out_param1));
110 _bt_delete_request_list(req_info->req_id);
114 g_free(func_data->address);
119 void _bt_audio_check_pending_connect()
122 bluetooth_device_address_t device_address;
127 if (pdata->pending == BT_PENDING_CONNECT) {
129 _bt_convert_addr_string_to_type(device_address.addr,
131 _bt_audio_connect(pdata->req_id,
136 g_free(pdata->address);
145 static void __bt_audio_request_cb(GDBusProxy *proxy, GAsyncResult *res,
148 GError *g_error = NULL;
149 GVariant *out_param1 = NULL;
150 GVariant *reply = NULL;
151 int result = BLUETOOTH_ERROR_NONE;
152 bt_audio_function_data_t *func_data;
153 request_info_t *req_info;
155 reply = g_dbus_proxy_call_finish(proxy, res, &g_error);
156 g_object_unref(proxy);
157 g_variant_unref(reply);
159 func_data = user_data;
161 if (func_data == NULL) {
163 BT_ERR("func_data == NULL");
167 if (func_data->pending != BT_PENDING_NONE && g_error == NULL) {
169 bluetooth_device_address_t device_address;
170 _bt_convert_addr_string_to_type(device_address.addr,
173 if (func_data->pending == BT_PENDING_CONNECT) {
175 if (__bt_device_support_uuid(func_data->address,
178 pdata = g_new0(bt_audio_function_data_t, 1);
179 pdata->req_id = func_data->req_id;
180 pdata->out_param = func_data->out_param;
181 pdata->address = strdup(func_data->address);
182 pdata->pending = func_data->pending;
188 if (_bt_is_service_connected(func_data->address
190 _bt_audio_disconnect(func_data->req_id,
193 func_data->out_param);
202 req_info = _bt_get_request_info(func_data->req_id);
203 if (req_info == NULL) {
204 BT_ERR("req_info == NULL");
211 BT_ERR("Audio Connect/Disconnect Dbus Call Error: %s\n", g_error->message);
213 result = BLUETOOTH_ERROR_INTERNAL;
215 /* Remove the device from the list */
216 _bt_remove_headset_from_list(func_data->type, func_data->address);
218 /* Error, check if any waiting device is there */
219 if (g_wait_data == NULL)
222 if (g_strcmp0(g_wait_data->address, func_data->address) != 0) {
223 bluetooth_device_address_t device_address;
224 _bt_convert_addr_string_to_type(device_address.addr,
225 g_wait_data->address);
226 _bt_audio_connect(g_wait_data->req_id, g_wait_data->type,
227 &device_address, g_wait_data->out_param1);
230 /* Event will be sent by the event reciever */
232 if (req_info->context == NULL) {
233 BT_DBG("req_info->context is NULL");
237 out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
238 func_data->address, BT_ADDRESS_STR_LEN, TRUE, NULL, NULL);
240 g_dbus_method_invocation_return_value(req_info->context,
241 g_variant_new("(iv)", result, out_param1));
243 _bt_delete_request_list(req_info->req_id);
245 g_clear_error(&g_error);
248 g_free(func_data->address);
253 static void __bt_free_wait_data()
255 if (g_wait_data != NULL) {
256 g_free(g_wait_data->address);
262 static void __bt_remove_device_from_wait_list()
264 /* Before deleting the request update the UI */
265 GVariant *out_param_1 = NULL;
266 int result = BLUETOOTH_ERROR_INTERNAL;
267 request_info_t *req_info;
269 req_info = _bt_get_request_info(g_wait_data->req_id);
270 if (req_info == NULL) {
271 BT_ERR("req_info == NULL");
275 out_param_1 = g_variant_new_from_data((const GVariantType *)"ay",
276 g_wait_data->address, BT_ADDRESS_STR_LEN, TRUE, NULL, NULL);
278 g_dbus_method_invocation_return_value(req_info->context,
279 g_variant_new("(iv)", result, out_param_1));
281 _bt_delete_request_list(g_wait_data->req_id);
284 static void __bt_set_headset_disconnection_type(const char *address)
286 bt_connected_headset_data_t *connected_device;
289 node = g_list_first(g_connected_list);
290 while (node != NULL) {
291 connected_device = node->data;
292 if (g_strcmp0(connected_device->device_address, address) == 0) {
293 g_wait_data->disconnection_type = connected_device->type;
296 node = g_list_next(node);
300 gboolean _bt_is_headset_type_connected(int type, char *address)
304 node = g_list_first(g_connected_list);
305 while (node != NULL) {
306 bt_connected_headset_data_t *connected_device = node->data;
308 if (connected_device->type & type) {
310 g_strlcpy(address, connected_device->device_address,
311 BT_ADDRESS_STRING_SIZE + 1);
315 node = g_list_next(node);
320 #ifdef TIZEN_SUPPORT_DUAL_HF
321 gboolean __bt_is_companion_device(const char *addr)
323 #ifdef TIZEN_WEARABLE
324 char *host_device_address = NULL;
325 host_device_address = vconf_get_str(VCONF_KEY_BT_HOST_BT_MAC_ADDR);
327 if (!host_device_address) {
328 BT_INFO("Failed to get a companion device address");
332 if (g_strcmp0(host_device_address, addr) == 0) {
333 BT_INFO("addr[%s] is companion device", addr);
339 /* TODO : Need to add companion device check condition for Phone models */
345 static int __bt_is_headset_connected(int type, int req_id,
346 const char *address, GArray **out_param1)
348 gboolean connected = FALSE;
349 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
350 bluetooth_device_address_t device_address;
351 bt_connected_headset_data_t *connected_device = NULL;
352 #ifdef TIZEN_SUPPORT_DUAL_HF
353 gboolean is_companion_device = FALSE;
356 /* Check if any other headset is connected */
359 node = g_list_first(g_connected_list);
360 while (node != NULL) {
361 connected_device = node->data;
362 if ((connected_device->type & type) == type) {
363 g_strlcpy(connected_address, connected_device->device_address,
364 BT_ADDRESS_STRING_SIZE + 1);
365 #ifdef TIZEN_SUPPORT_DUAL_HF
366 is_companion_device = __bt_is_companion_device(connected_address);
367 BT_INFO(" is_companion_device[%d]", is_companion_device);
369 if (!is_companion_device) {
378 node = g_list_next(node);
382 return BLUETOOTH_ERROR_NOT_CONNECTED;
384 BT_DBG("connected headset %s", connected_address);
386 if (g_strcmp0(connected_address, address) == 0)
387 return BLUETOOTH_ERROR_ALREADY_CONNECT;
388 #ifdef TIZEN_SUPPORT_DUAL_HF
389 else if (TRUE == __bt_is_companion_device(address))
390 return BLUETOOTH_ERROR_NOT_CONNECTED;
393 /* If already one device is waiting, remove current waiting device and add new */
394 if (g_wait_data != NULL) {
395 if (g_strcmp0(g_wait_data->address, address) != 0) {
396 __bt_remove_device_from_wait_list();
397 __bt_free_wait_data();
401 if (g_wait_data == NULL) {
402 g_wait_data = g_malloc0(sizeof(bt_headset_wait_t));
403 g_wait_data->address = g_strdup(address);
404 g_wait_data->req_id = req_id;
405 g_wait_data->type = type;
406 g_wait_data->ag_flag = FALSE;
407 g_wait_data->out_param1 = out_param1;
409 /* Set disconnection type */
410 __bt_set_headset_disconnection_type(connected_address);
413 /* Convert BD adress from string type */
414 _bt_convert_addr_string_to_type(device_address.addr, connected_address);
415 _bt_audio_disconnect(0, connected_device->type & type, &device_address, NULL);
416 return BLUETOOTH_ERROR_NONE;
419 void _bt_set_audio_wait_data_flag(gboolean flag)
421 BT_DBG("_bt_set_audio_wait_data_flag \n");
422 g_wait_data->ag_flag = flag;
425 bt_headset_wait_t *_bt_get_audio_wait_data(void)
427 BT_DBG("_bt_get_audio_wait_data \n");
431 void _bt_rel_wait_data(void)
433 BT_DBG("_bt_rel_wait_data \n");
434 __bt_free_wait_data();
437 void _bt_add_headset_to_list(int type, int status, const char *address)
439 bt_connected_headset_data_t *connected_device;
440 bt_connected_headset_data_t *device;
443 BT_DBG("_bt_add_headset_to_list \n");
445 node = g_list_first(g_connected_list);
446 while (node != NULL) {
447 device = (bt_connected_headset_data_t *)node->data;
449 if (g_strcmp0(device->device_address, address) == 0) {
450 BT_DBG("Address match, update connection type \n");
451 if (status == BT_STATE_CONNECTED)
452 device->type |= type;
453 device->device_state = status;
456 node = g_list_next(node);
459 connected_device = g_malloc0(sizeof(bt_connected_headset_data_t));
460 /* Fix : NULL_RETURNS */
461 if (connected_device == NULL) {
462 BT_ERR("No memory allocated");
466 connected_device->device_state = status;
467 if ((status == BT_STATE_CONNECTED) || (status == BT_STATE_CONNECTING))
468 connected_device->type |= type;
469 g_strlcpy(connected_device->device_address, address,
470 sizeof(connected_device->device_address));
471 g_connected_list = g_list_append(g_connected_list, connected_device);
474 int _bt_get_device_state_from_list(int type, const char *address)
477 bt_connected_headset_data_t *device;
480 node = g_list_first(g_connected_list);
481 while (node != NULL) {
482 device = (bt_connected_headset_data_t *)node->data;
483 if (g_strcmp0(device->device_address, address) == 0) {
484 BT_DBG("Device found");
485 return device->device_state;
487 node = g_list_next(node);
490 BT_DBG("Device not found");
491 return BLUETOOTH_ERROR_INTERNAL;
494 void _bt_remove_headset_from_list(int type, const char *address)
498 BT_DBG("_bt_remove_headset_from_list \n");
500 node = g_list_first(g_connected_list);
501 while (node != NULL) {
502 bt_connected_headset_data_t *connected_device = node->data;
504 if (g_strcmp0(connected_device->device_address, address) != 0) {
505 node = g_list_next(node);
509 BT_DBG("Address match \n");
511 BT_DBG("Connection type = %x\n", connected_device->type);
515 if (connected_device->type & BT_AUDIO_A2DP)
516 connected_device->type &= ~(BT_AUDIO_A2DP);
519 if (connected_device->type & BT_AUDIO_HSP)
520 connected_device->type &= ~(BT_AUDIO_HSP);
523 if (connected_device->type & BT_AUDIO_ALL)
524 connected_device->type &= ~(BT_AUDIO_ALL);
527 if (connected_device->type & BT_AVRCP)
528 connected_device->type &= ~(BT_AVRCP);
532 BT_DBG("Connection type = %x\n", connected_device->type);
534 if (connected_device->type == 0x00) {
535 g_connected_list = g_list_remove(g_connected_list, connected_device);
536 g_free(connected_device);
539 node = g_list_next(node);
543 static gboolean __bt_device_support_uuid(char *remote_address,
544 bt_audio_type_t type)
546 GArray *dev_list = NULL;
550 bluetooth_device_info_t info;
551 char bond_address[BT_ADDRESS_STRING_SIZE] = { 0 };
552 gboolean ret = FALSE;
556 dev_list = g_array_new(FALSE, FALSE, sizeof(gchar));
558 _bt_get_bonded_devices(&dev_list);
559 size = (dev_list->len) / sizeof(bluetooth_device_info_t);
561 for (i = 0; i < size; i++) {
562 info = g_array_index(dev_list, bluetooth_device_info_t, i);
563 _bt_convert_addr_type_to_string(bond_address,
564 info.device_address.addr);
565 if (strcmp(bond_address, remote_address) != 0)
568 BT_INFO("Device address Matched");
570 while (j != info.service_index) {
571 if (type == BT_AUDIO_HSP) {
572 if (strcmp(info.uuids[j], HFP_HS_UUID) == 0) {
573 BT_INFO("HFP HS UUID exists");
577 } else if (type == BT_AUDIO_A2DP) {
578 if (strcmp(info.uuids[j], A2DP_SINK_UUID) == 0) {
579 BT_INFO("A2DP SINK UUID exists");
588 g_array_free(dev_list, TRUE);
593 gboolean _bt_is_service_connected(char* address, int type)
597 node = g_list_first(g_connected_list);
598 while (node != NULL) {
599 bt_connected_headset_data_t *conn_device = node->data;
601 if ((g_strcmp0(conn_device->device_address, address) == 0) &&
602 (conn_device->type & type)) {
603 BT_INFO("Service connected");
607 node = g_list_next(node);
609 BT_INFO("Service not connected");
613 int _bt_audio_connect(int request_id, int type,
614 bluetooth_device_address_t *device_address,
617 int result = BLUETOOTH_ERROR_NONE;
618 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
619 GDBusProxy *adapter_proxy;
620 GDBusConnection *g_conn;
623 int value = BLUETOOTH_ERROR_NONE;
624 bt_audio_function_data_t *func_data;
626 BT_CHECK_PARAMETER(device_address, return);
628 adapter_proxy = _bt_get_adapter_proxy();
629 retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
631 g_conn = _bt_get_system_gconn();
632 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
634 _bt_convert_addr_type_to_string(address, device_address->addr);
636 func_data = g_malloc0(sizeof(bt_audio_function_data_t));
637 /* Fix : NULL_RETURNS */
638 if (func_data == NULL) {
639 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
643 func_data->address = g_strdup(address);
644 func_data->req_id = request_id;
645 func_data->type = type;
646 func_data->pending = BT_PENDING_NONE;
647 func_data->out_param = out_param1;
654 uuid = A2DP_SINK_UUID;
657 uuid = AVRCP_TARGET_UUID;
659 case BT_AUDIO_A2DP_SOURCE:
660 uuid = A2DP_SOURCE_UUID;
663 if (__bt_device_support_uuid(address, BT_AUDIO_HSP)) {
665 func_data->pending = BT_PENDING_CONNECT;
667 } else if (__bt_device_support_uuid(address, BT_AUDIO_A2DP)) {
668 uuid = A2DP_SINK_UUID;
669 type = BT_AUDIO_A2DP;
671 BT_ERR("No audio role supported");
672 result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
677 BT_ERR("Unknown role");
678 result = BLUETOOTH_ERROR_INTERNAL;
681 BT_INFO("Connecting to service %s", uuid);
683 value = __bt_is_headset_connected(type, request_id, address, out_param1);
685 if (value == BLUETOOTH_ERROR_ALREADY_CONNECT) {
686 return BLUETOOTH_ERROR_ALREADY_CONNECT;
687 } else if (value == BLUETOOTH_ERROR_NOT_CONNECTED) {
688 _bt_headset_set_local_connection(TRUE);
689 ret = _bt_connect_profile(address, uuid,
690 __bt_audio_request_cb, func_data);
692 if (ret != BLUETOOTH_ERROR_NONE) {
693 BT_ERR("_bt_connect_profile Error");
694 _bt_headset_set_local_connection(FALSE);
695 g_free(func_data->address);
700 /* Add data to the connected list */
701 _bt_add_headset_to_list(type, BT_STATE_CONNECTING, address);
704 return BLUETOOTH_ERROR_NONE;
706 g_array_append_vals(*out_param1, address,
712 int _bt_audio_disconnect(int request_id, int type,
713 bluetooth_device_address_t *device_address,
716 int result = BLUETOOTH_ERROR_NONE;
717 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
718 bt_audio_function_data_t *func_data;
719 GDBusProxy *adapter_proxy;
720 GDBusConnection *g_conn;
725 BT_CHECK_PARAMETER(device_address, return);
727 adapter_proxy = _bt_get_adapter_proxy();
728 retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
730 g_conn = _bt_get_system_gconn();
731 retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
733 _bt_convert_addr_type_to_string(address, device_address->addr);
735 func_data = g_malloc0(sizeof(bt_audio_function_data_t));
736 retv_if(func_data == NULL, BLUETOOTH_ERROR_INTERNAL);
738 func_data->address = g_strdup(address);
739 func_data->req_id = request_id;
740 func_data->pending = BT_PENDING_NONE;
741 func_data->out_param = out_param1;
742 func_data->type = type;
749 uuid = A2DP_SINK_UUID;
752 uuid = AVRCP_TARGET_UUID;
754 case BT_AUDIO_A2DP_SOURCE:
755 uuid = A2DP_SOURCE_UUID;
758 if (_bt_is_service_connected(address, BT_AUDIO_HSP)) {
760 func_data->pending = BT_PENDING_DISCONNECT;
761 } else if (_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
762 uuid = A2DP_SINK_UUID;
764 BT_ERR("No audio service connected");
765 result = BLUETOOTH_ERROR_NOT_CONNECTED;
770 BT_ERR("Unknown role");
771 result = BLUETOOTH_ERROR_INTERNAL;
775 BT_INFO("Disconnecting service %s", uuid);
776 ret = _bt_disconnect_profile(address, uuid,
777 __bt_audio_request_cb, func_data);
779 if (ret != BLUETOOTH_ERROR_NONE) {
780 BT_ERR("_bt_disconnect_profile Error");
781 g_free(func_data->address);
787 * This logic is added for dual HF mode issue.
789 node = g_list_first(g_connected_list);
790 while (node != NULL) {
791 bt_connected_headset_data_t *connected_device = node->data;
793 if (g_strcmp0(connected_device->device_address, address) == 0) {
794 BT_DBG("Connection type update");
795 type = connected_device->type;
798 node = g_list_next(node);
800 _bt_add_headset_to_list(type, BT_STATE_DISCONNECTING, address);
802 return BLUETOOTH_ERROR_NONE;
804 if (out_param1 != NULL)
805 g_array_append_vals(*out_param1, address,
811 void _bt_remove_from_connected_list(const char *address)
813 bt_connected_headset_data_t *connected_device;
816 node = g_list_first(g_connected_list);
817 while (node != NULL) {
818 connected_device = node->data;
819 if (connected_device != NULL &&
820 g_strcmp0(connected_device->device_address, address) == 0) {
821 BT_ERR("Device is removed from the list");
822 g_connected_list = g_list_remove(g_connected_list, connected_device);
823 g_free(connected_device);
826 node = g_list_next(node);
830 int _bt_hf_connect(int request_id,
831 bluetooth_device_address_t *device_address,
834 int result = BLUETOOTH_ERROR_NONE;
835 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
836 bt_function_data_t *func_data;
837 GDBusProxy *adapter_proxy;
838 GDBusConnection *g_conn;
842 BT_CHECK_PARAMETER(device_address, return);
844 _bt_convert_addr_type_to_string(address, device_address->addr);
846 adapter_proxy = _bt_get_adapter_proxy();
847 if (adapter_proxy == NULL) {
848 result = BLUETOOTH_ERROR_INTERNAL;
852 g_conn = _bt_get_system_gconn();
853 if (g_conn == NULL) {
854 result = BLUETOOTH_ERROR_INTERNAL;
858 func_data = g_malloc0(sizeof(bt_function_data_t));
859 /* Fix : NULL_RETURNS */
860 if (func_data == NULL) {
861 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
865 func_data->address = g_strdup(address);
866 func_data->req_id = request_id;
867 uuid = g_strdup(HFP_AG_UUID);
869 BT_DBG("Connecting to service %s", uuid);
871 ret = _bt_connect_profile(address, uuid,
872 __bt_hf_request_cb, func_data);
874 if (ret != BLUETOOTH_ERROR_NONE) {
875 BT_ERR("_bt_connect_profile Error");
876 g_free(func_data->address);
882 return BLUETOOTH_ERROR_NONE;
884 if (out_param1 != NULL)
885 g_array_append_vals(*out_param1, address,
891 int _bt_hf_disconnect(int request_id,
892 bluetooth_device_address_t *device_address,
895 int result = BLUETOOTH_ERROR_NONE;
896 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
897 bt_function_data_t *func_data;
898 GDBusProxy *adapter_proxy;
899 GDBusConnection *g_conn;
904 BT_CHECK_PARAMETER(device_address, return);
906 _bt_convert_addr_type_to_string(address, device_address->addr);
908 adapter_proxy = _bt_get_adapter_proxy();
909 if (adapter_proxy == NULL) {
910 result = BLUETOOTH_ERROR_INTERNAL;
914 g_conn = _bt_get_system_gconn();
915 if (g_conn == NULL) {
916 result = BLUETOOTH_ERROR_INTERNAL;
920 func_data = g_malloc0(sizeof(bt_function_data_t));
921 /* Fix : NULL_RETURNS */
922 if (func_data == NULL) {
923 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
927 func_data->address = g_strdup(address);
928 func_data->req_id = request_id;
929 uuid = g_strdup(HFP_AG_UUID);
931 BT_DBG("Disconnecting service %s", uuid);
932 ret = _bt_disconnect_profile(address, uuid,
933 __bt_hf_request_cb, func_data);
935 if (ret != BLUETOOTH_ERROR_NONE) {
936 BT_ERR("_bt_disconnect_profile Error");
937 g_free(func_data->address);
943 return BLUETOOTH_ERROR_NONE;
945 if (out_param1 != NULL)
946 g_array_append_vals(*out_param1, address,
952 int _bt_audio_set_content_protect(gboolean status)
954 GDBusConnection *conn;
955 GError *error = NULL;
959 conn = _bt_get_system_gconn();
960 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
962 BT_DBG("Content Protection status = [%d]", status);
964 g_dbus_connection_emit_signal(conn,
965 NULL, BT_CONTENT_PROTECTION_PATH,
966 BT_CONTENT_PROTECTION_INTERFACE,
967 "ProtectionRequired",
968 g_variant_new("(b)", status),
972 /* dBUS gives error cause */
973 ERR("Could not Emit Signal: errCode[%x], message[%s]",
974 error->code, error->message);
975 g_clear_error(&error);
976 return BLUETOOTH_ERROR_INTERNAL;
979 BT_DBG("Emit Signal done = [ProtectionRequired]");
980 return BLUETOOTH_ERROR_NONE;