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.
20 #include "bluetooth-api.h"
21 #include "bluetooth-audio-api.h"
22 #include "bt-internal-types.h"
24 #include "bt-common.h"
25 #include "bt-request-sender.h"
26 #include "bt-event-handler.h"
27 #ifdef TIZEN_DPM_ENABLE
31 BT_EXPORT_API int bluetooth_audio_init(bt_audio_func_ptr cb, void *user_data)
36 BT_ERR("callback is NULL");
37 return BLUETOOTH_ERROR_INVALID_PARAM;
39 ret = _bt_init_event_handler();
41 if (ret != BLUETOOTH_ERROR_NONE &&
42 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
43 BT_ERR("Fail to init the event handler");
47 _bt_set_user_data(BT_AUDIO, (void *)cb, user_data);
49 /* Register All events */
50 ret = _bt_register_event(BT_HEADSET_EVENT, (void *)cb, user_data);
51 if (ret != BLUETOOTH_ERROR_NONE &&
52 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
53 _bt_deinit_event_handler();
57 ret = _bt_register_event(BT_A2DP_SOURCE_EVENT, (void *)cb, user_data);
58 if (ret != BLUETOOTH_ERROR_NONE &&
59 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
60 _bt_deinit_event_handler();
64 return BLUETOOTH_ERROR_NONE;
67 BT_EXPORT_API int bluetooth_audio_deinit(void)
69 _bt_unregister_event(BT_HEADSET_EVENT);
70 _bt_unregister_event(BT_A2DP_SOURCE_EVENT);
71 _bt_set_user_data(BT_AUDIO, NULL, NULL);
73 return BLUETOOTH_ERROR_NONE;
76 BT_EXPORT_API int bluetooth_audio_connect(bluetooth_device_address_t *remote_address)
78 int service_function = BT_AUDIO_CONNECT;
80 bt_user_info_t *user_info;
82 BT_CHECK_PARAMETER(remote_address, return);
83 BT_CHECK_ENABLED(return);
85 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_CONNECT)
86 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
87 BT_ERR("Don't have a privilege to use this API");
88 return BLUETOOTH_ERROR_PERMISSION_DEINED;
91 #ifdef TIZEN_DPM_ENABLE
92 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
93 BT_ERR("Blacklist device");
94 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
97 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED &&
98 _bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
99 BT_ERR("Not allow to use HSP / A2DP profile");
100 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
101 } else if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
102 BT_ERR("Not allow to use HSP profile");
103 service_function = BT_AV_CONNECT;
104 } else if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
105 BT_ERR("Not allow to use A2DP profile");
106 service_function = BT_AG_CONNECT;
109 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
110 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
111 bluetooth_device_class_t dev_class;
113 _bt_convert_addr_type_to_string(address, remote_address->addr);
114 _bt_get_cod_by_address(address, &dev_class);
116 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
117 BT_ERR("Reject a authorization due to MDM Policy");
118 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
123 user_info = _bt_get_user_data(BT_AUDIO);
124 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
127 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
129 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
131 result = _bt_send_request_async(BT_BLUEZ_SERVICE, service_function,
132 in_param1, in_param2, in_param3, in_param4,
133 user_info->cb, user_info->user_data);
135 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
140 BT_EXPORT_API int bluetooth_audio_disconnect(bluetooth_device_address_t *remote_address)
143 bt_user_info_t *user_info;
145 BT_CHECK_PARAMETER(remote_address, return);
146 BT_CHECK_ENABLED(return);
148 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_DISCONNECT)
149 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
150 BT_ERR("Don't have a privilege to use this API");
151 return BLUETOOTH_ERROR_PERMISSION_DEINED;
154 user_info = _bt_get_user_data(BT_AUDIO);
155 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
158 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
160 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
162 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_DISCONNECT,
163 in_param1, in_param2, in_param3, in_param4,
164 user_info->cb, user_info->user_data);
166 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
171 BT_EXPORT_API int bluetooth_ag_connect(bluetooth_device_address_t *remote_address)
174 bt_user_info_t *user_info;
176 BT_CHECK_PARAMETER(remote_address, return);
177 BT_CHECK_ENABLED(return);
179 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_CONNECT)
180 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
181 BT_ERR("Don't have a privilege to use this API");
182 return BLUETOOTH_ERROR_PERMISSION_DEINED;
185 #ifdef TIZEN_DPM_ENABLE
186 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
187 BT_ERR("Blacklist device");
188 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
191 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
192 BT_ERR("Not allow to use HSP profile");
193 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
196 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
197 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
198 bluetooth_device_class_t dev_class;
200 _bt_convert_addr_type_to_string(address, remote_address->addr);
201 _bt_get_cod_by_address(address, &dev_class);
203 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
204 BT_ERR("Reject a authorization due to MDM Policy");
205 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
210 user_info = _bt_get_user_data(BT_AUDIO);
211 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
214 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
216 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
218 BT_INFO_C("### Connect AG");
219 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
220 in_param1, in_param2, in_param3, in_param4,
221 user_info->cb, user_info->user_data);
223 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
228 BT_EXPORT_API int bluetooth_ag_disconnect(bluetooth_device_address_t *remote_address)
231 bt_user_info_t *user_info;
233 BT_CHECK_PARAMETER(remote_address, return);
234 BT_CHECK_ENABLED(return);
236 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_DISCONNECT)
237 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
238 BT_ERR("Don't have a privilege to use this API");
239 return BLUETOOTH_ERROR_PERMISSION_DEINED;
242 user_info = _bt_get_user_data(BT_AUDIO);
243 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
246 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
248 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
250 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_DISCONNECT,
251 in_param1, in_param2, in_param3, in_param4,
252 user_info->cb, user_info->user_data);
254 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
259 BT_EXPORT_API int bluetooth_av_connect(bluetooth_device_address_t *remote_address)
262 bt_user_info_t *user_info;
264 BT_CHECK_PARAMETER(remote_address, return);
265 BT_CHECK_ENABLED(return);
267 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_CONNECT)
268 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
269 BT_ERR("Don't have a privilege to use this API");
270 return BLUETOOTH_ERROR_PERMISSION_DEINED;
273 #ifdef TIZEN_DPM_ENABLE
274 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
275 BT_ERR("Blacklist device");
276 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
279 if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
280 BT_ERR("Not allow to use A2DP profile");
281 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
284 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
285 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
286 bluetooth_device_class_t dev_class;
288 _bt_convert_addr_type_to_string(address, remote_address->addr);
289 _bt_get_cod_by_address(address, &dev_class);
291 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
292 BT_ERR("Reject a authorization due to MDM Policy");
293 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
298 user_info = _bt_get_user_data(BT_AUDIO);
299 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
302 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
304 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
306 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
307 in_param1, in_param2, in_param3, in_param4,
308 user_info->cb, user_info->user_data);
310 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
315 BT_EXPORT_API int bluetooth_av_source_connect(bluetooth_device_address_t *remote_address)
318 bt_user_info_t *user_info;
320 BT_CHECK_PARAMETER(remote_address, return);
321 BT_CHECK_ENABLED(return);
323 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_CONNECT)
324 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
325 BT_ERR("Don't have a privilege to use this API");
326 return BLUETOOTH_ERROR_PERMISSION_DEINED;
329 #ifdef TIZEN_DPM_ENABLE
330 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
331 BT_ERR("Blacklist device");
332 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
335 if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
336 BT_ERR("Not allow to use A2DP profile");
337 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
341 user_info = _bt_get_user_data(BT_AUDIO);
342 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
345 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
347 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
349 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_CONNECT,
350 in_param1, in_param2, in_param3, in_param4,
351 user_info->cb, user_info->user_data);
353 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
358 BT_EXPORT_API int bluetooth_av_disconnect(bluetooth_device_address_t *remote_address)
361 bt_user_info_t *user_info;
363 BT_CHECK_PARAMETER(remote_address, return);
364 BT_CHECK_ENABLED(return);
366 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_DISCONNECT)
367 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
368 BT_ERR("Don't have a privilege to use this API");
369 return BLUETOOTH_ERROR_PERMISSION_DEINED;
372 user_info = _bt_get_user_data(BT_AUDIO);
373 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
376 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
378 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
380 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_DISCONNECT,
381 in_param1, in_param2, in_param3, in_param4,
382 user_info->cb, user_info->user_data);
384 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
389 BT_EXPORT_API int bluetooth_av_source_disconnect(bluetooth_device_address_t *remote_address)
392 bt_user_info_t *user_info;
394 BT_CHECK_PARAMETER(remote_address, return);
395 BT_CHECK_ENABLED(return);
397 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_DISCONNECT)
398 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
399 BT_ERR("Don't have a privilege to use this API");
400 return BLUETOOTH_ERROR_PERMISSION_DEINED;
403 user_info = _bt_get_user_data(BT_AUDIO);
404 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
407 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
409 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
411 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_DISCONNECT,
412 in_param1, in_param2, in_param3, in_param4,
413 user_info->cb, user_info->user_data);
415 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
420 BT_EXPORT_API int bluetooth_ag_get_headset_volume(unsigned int *speaker_gain)
424 BT_CHECK_PARAMETER(speaker_gain, return);
425 BT_CHECK_ENABLED(return);
428 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
430 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SPEAKER_GAIN,
431 in_param1, in_param2, in_param3, in_param4, &out_param);
433 if (result == BLUETOOTH_ERROR_NONE) {
434 *speaker_gain = g_array_index(out_param,
438 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
443 BT_EXPORT_API int bluetooth_ag_set_speaker_gain(unsigned int speaker_gain)
447 BT_CHECK_ENABLED(return);
449 #ifdef TIZEN_DPM_ENABLE
450 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
451 BT_ERR("Not allow to use HSP profile");
452 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
457 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
459 g_array_append_vals(in_param1, &speaker_gain, sizeof(unsigned int));
461 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SPEAKER_GAIN,
462 in_param1, in_param2, in_param3, in_param4, &out_param);
464 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
469 #define BT_HF_SERVICE_NAME "org.bluez.hf_agent"
470 #define BT_HF_OBJECT_PATH "/org/bluez/handsfree_agent"
471 #define BT_HF_INTERFACE "org.tizen.HfApp"
474 static GVariant* __bt_hf_agent_dbus_send(const char *path, const char *interface,
475 const char *method, GError **err, GVariant *parameters)
477 GVariant *reply = NULL;
478 GDBusProxy *proxy = NULL;
479 GDBusConnection *conn = NULL;
481 conn = _bt_gdbus_get_system_gconn();
482 retv_if(conn == NULL, NULL);
484 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
485 NULL, BT_HF_SERVICE_NAME, path, interface, NULL, err);
487 BT_ERR("Unable to allocate new proxy");
491 reply = g_dbus_proxy_call_sync(proxy, method, parameters,
492 G_DBUS_CALL_FLAGS_NONE, -1, NULL, err);
494 g_object_unref(proxy);
498 static int __bt_hf_agent_read_call_list(GVariant *reply,
499 bt_hf_call_list_s **call_list) {
502 GVariant *var_temp = NULL;
505 int dir, status, mpart, idx;
509 g_variant_get(reply, "(i@a(siiii))", &call_count, &var_temp);
511 if (call_count <= 0) {
513 return BLUETOOTH_ERROR_NOT_FOUND;
515 BT_DBG("Call count = %d", call_count);
517 *call_list = g_malloc0(sizeof(bt_hf_call_list_s));
518 /* Fix : NULL_RETURNS */
519 retv_if(*call_list == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
521 (*call_list)->count = call_count;
523 g_variant_iter_init(&iter, var_temp);
524 while (g_variant_iter_loop(&iter, "(siiii)", &num, &dir, &status, &mpart, &idx)) {
525 bt_hf_call_status_info_t *call_info;
527 call_info = g_malloc0(sizeof(bt_hf_call_status_info_t));
528 /* Fix : NULL_RETURNS */
529 retv_if(call_info == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
531 call_info->number = g_strdup(num);
532 call_info->direction = dir;
533 call_info->status = status;
534 call_info->mpart = mpart;
535 call_info->idx = idx;
537 (*call_list)->list = g_list_append((*call_list)->list,
538 (gpointer)call_info);
541 return BLUETOOTH_ERROR_NONE;
544 static int __bluetooth_hf_get_error(const char *error_message)
546 if (error_message == NULL) {
547 BT_ERR("Error message NULL");
548 return BLUETOOTH_ERROR_INTERNAL;
551 BT_ERR("Error message = %s", error_message);
553 if (g_strcmp0(error_message, "NotConnected") == 0)
554 return BLUETOOTH_ERROR_NOT_CONNECTED;
556 return BLUETOOTH_ERROR_INTERNAL;
559 BT_EXPORT_API int bluetooth_hf_init(bt_hf_func_ptr cb, void *user_data)
564 BT_ERR("callback is NULL");
565 return BLUETOOTH_ERROR_INVALID_PARAM;
568 ret = _bt_init_event_handler();
570 if (ret != BLUETOOTH_ERROR_NONE &&
571 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
572 BT_ERR("Fail to init the event handler");
576 _bt_set_user_data(BT_HF, (void *)cb, user_data);
578 /* Register All events */
579 ret = _bt_register_event(BT_HF_AGENT_EVENT, (void *)cb, user_data);
580 if (ret != BLUETOOTH_ERROR_NONE &&
581 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
582 _bt_deinit_event_handler();
586 return BLUETOOTH_ERROR_NONE;
589 BT_EXPORT_API int bluetooth_hf_deinit(void)
593 ret = _bt_unregister_event(BT_HF_AGENT_EVENT);
594 if (ret != BLUETOOTH_ERROR_NONE)
595 BT_ERR("_bt_unregister_event failed");
597 _bt_set_user_data(BT_HF, NULL, NULL);
599 return BLUETOOTH_ERROR_NONE;
602 BT_EXPORT_API int bluetooth_hf_connect(bluetooth_device_address_t *remote_address)
605 bt_user_info_t *user_info;
607 BT_CHECK_ENABLED(return);
608 BT_CHECK_PARAMETER(remote_address, return);
610 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_CONNECT)
611 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
612 BT_ERR("Don't have a privilege to use this API");
613 return BLUETOOTH_ERROR_PERMISSION_DEINED;
616 user_info = _bt_get_user_data(BT_HF);
617 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
620 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
622 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
624 BT_INFO_C("### Connect HF");
625 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_CONNECT,
626 in_param1, in_param2, in_param3, in_param4,
627 user_info->cb, user_info->user_data);
629 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
634 BT_EXPORT_API int bluetooth_hf_disconnect(bluetooth_device_address_t *remote_address)
637 bt_user_info_t *user_info;
639 BT_CHECK_PARAMETER(remote_address, return);
640 BT_CHECK_ENABLED(return);
642 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_DISCONNECT)
643 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
644 BT_ERR("Don't have a privilege to use this API");
645 return BLUETOOTH_ERROR_PERMISSION_DEINED;
648 user_info = _bt_get_user_data(BT_HF);
649 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
652 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
654 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
656 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_DISCONNECT,
657 in_param1, in_param2, in_param3, in_param4,
658 user_info->cb, user_info->user_data);
660 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
665 BT_EXPORT_API int bluetooth_hf_answer_call()
667 GVariant *reply = NULL;
669 int ret = BLUETOOTH_ERROR_INTERNAL;
671 BT_CHECK_ENABLED(return);
673 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
674 "AnswerCall", &err, NULL);
676 BT_ERR("Error returned in method call\n");
678 BT_ERR("Error = %s", err->message);
679 g_dbus_error_strip_remote_error(err);
680 if (strcmp(err->message, "Operation not supported") == 0)
681 ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
682 else if (strcmp(err->message, "Operation not allowed") == 0)
683 ret = BLUETOOTH_ERROR_PERMISSION_DEINED;
685 ret = BLUETOOTH_ERROR_INTERNAL;
691 g_variant_unref(reply);
692 return BLUETOOTH_ERROR_NONE;
696 BT_EXPORT_API int bluetooth_hf_terminate_call()
698 GVariant *reply = NULL;
701 BT_CHECK_ENABLED(return);
703 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
704 "TerminateCall", &err, NULL);
706 BT_ERR("Error returned in method call\n");
708 BT_ERR("Error = %s", err->message);
711 return BLUETOOTH_ERROR_INTERNAL;
714 g_variant_unref(reply);
715 return BLUETOOTH_ERROR_NONE;
718 BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
720 GVariant *reply = NULL;
722 GVariant *param = NULL;
723 int ret = BLUETOOTH_ERROR_INTERNAL;
725 BT_CHECK_ENABLED(return);
730 param = g_variant_new("(s)", number);
731 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
732 "InitiateCall", &err, param);
734 BT_ERR("Error returned in method call");
736 BT_ERR("Error = %s", err->message);
737 g_dbus_error_strip_remote_error(err);
738 if (strcmp(err->message, "NotConnected") == 0)
739 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
740 else if (strcmp(err->message, "Operation not allowed") == 0)
741 ret = BLUETOOTH_ERROR_IN_PROGRESS;
743 ret = BLUETOOTH_ERROR_INTERNAL;
749 g_variant_unref(reply);
750 return BLUETOOTH_ERROR_NONE;
753 BT_EXPORT_API int bluetooth_hf_voice_recognition(unsigned int status)
755 GVariant *reply = NULL;
757 GVariant *param = NULL;
759 BT_CHECK_ENABLED(return);
761 param = g_variant_new("(i)", status);
762 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
763 "VoiceRecognition", &err, param);
765 BT_ERR("Error returned in method call\n");
767 BT_ERR("Error = %s", err->message);
770 return BLUETOOTH_ERROR_INTERNAL;
773 g_variant_unref(reply);
774 return BLUETOOTH_ERROR_NONE;
777 BT_EXPORT_API int bluetooth_hf_audio_disconnect(void)
779 GVariant *reply = NULL;
782 BT_CHECK_ENABLED(return);
784 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
785 "ScoDisconnect", &err, NULL);
787 BT_ERR("Error returned in method call\n");
789 BT_ERR("Error = %s", err->message);
792 return BLUETOOTH_ERROR_INTERNAL;
795 g_variant_unref(reply);
796 return BLUETOOTH_ERROR_NONE;
799 BT_EXPORT_API int bluetooth_hf_set_speaker_gain(unsigned int speaker_gain)
801 GVariant *reply = NULL;
803 GVariant *param = NULL;
805 BT_CHECK_ENABLED(return);
807 param = g_variant_new("(u)", speaker_gain);
808 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
809 "SpeakerGain", &err, param);
811 BT_ERR("Error returned in method call\n");
813 BT_ERR("Error = %s", err->message);
816 return BLUETOOTH_ERROR_INTERNAL;
819 g_variant_unref(reply);
820 return BLUETOOTH_ERROR_NONE;
823 BT_EXPORT_API int bluetooth_hf_send_dtmf(char *dtmf)
825 GVariant *reply = NULL;
827 GVariant *param = NULL;
829 BT_CHECK_ENABLED(return);
831 param = g_variant_new("(s)", dtmf);
832 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
833 "SendDtmf", &err, param);
835 BT_ERR("Error returned in method call\n");
837 BT_ERR("Error = %s", err->message);
840 return BLUETOOTH_ERROR_INTERNAL;
843 g_variant_unref(reply);
844 return BLUETOOTH_ERROR_NONE;
847 BT_EXPORT_API int bluetooth_hf_send_xsat_cmd(int app_id, char *xsat_cmd)
849 GVariant *reply = NULL;
851 GVariant *param = NULL;
852 char buffer[200] = {0,};
855 BT_CHECK_ENABLED(return);
857 strncpy(buffer, "AT+XSAT=\0", 200);
858 snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer),
860 strncat(buffer, xsat_cmd, (sizeof(buffer) - 1) - strlen(buffer));
861 BT_DBG("Xsat cmd received = %s", buffer);
863 param = g_variant_new("(s)", ptr);
865 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
866 "SendAtCmd", &err, param);
868 BT_ERR("Error returned in method call\n");
870 BT_ERR("Error = %s", err->message);
873 return BLUETOOTH_ERROR_INTERNAL;
876 g_variant_unref(reply);
877 return BLUETOOTH_ERROR_NONE;
880 BT_EXPORT_API int bluetooth_hf_release_and_accept(void)
882 GVariant *reply = NULL;
885 BT_CHECK_ENABLED(return);
887 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
888 "ReleaseAndAccept", &err, NULL);
890 BT_ERR("Error returned in method call\n");
892 BT_ERR("Error = %s", err->message);
895 return BLUETOOTH_ERROR_INTERNAL;
898 g_variant_unref(reply);
899 return BLUETOOTH_ERROR_NONE;
902 BT_EXPORT_API int bluetooth_hf_swap_call(void)
904 GVariant *reply = NULL;
907 BT_CHECK_ENABLED(return);
909 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
910 "CallSwap", &err, NULL);
912 BT_ERR("Error returned in method call\n");
914 BT_ERR("Error = %s", err->message);
917 return BLUETOOTH_ERROR_INTERNAL;
920 g_variant_unref(reply);
921 return BLUETOOTH_ERROR_NONE;
924 BT_EXPORT_API int bluetooth_hf_release_all_call(void)
926 GVariant *reply = NULL;
929 BT_CHECK_ENABLED(return);
931 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
932 "ReleaseAllCall", &err, NULL);
934 BT_ERR("Error returned in method call\n");
936 BT_ERR("Error = %s", err->message);
939 return BLUETOOTH_ERROR_INTERNAL;
942 g_variant_unref(reply);
943 return BLUETOOTH_ERROR_NONE;
946 BT_EXPORT_API int bluetooth_hf_join_call(void)
948 GVariant *reply = NULL;
951 BT_CHECK_ENABLED(return);
953 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
954 "JoinCall", &err, NULL);
956 BT_ERR("Error returned in method call\n");
958 BT_ERR("Error = %s", err->message);
961 return BLUETOOTH_ERROR_INTERNAL;
964 g_variant_unref(reply);
965 return BLUETOOTH_ERROR_NONE;
968 BT_EXPORT_API int bluetooth_hf_get_call_list(void *call_list,
969 bt_hf_call_status_info_t **call_status)
972 GList *list = call_list;
974 bt_hf_call_status_info_t * call_info;
976 BT_CHECK_ENABLED(return);
977 retv_if(list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
978 retv_if(call_status == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
980 call_count = g_list_length(list);
982 BT_DBG(" call_count = [%d]", call_count);
984 for (i = 0; i < call_count; i++) {
985 call_info = g_list_nth_data(list, i);
986 BT_DBG(" direction = [%d]", call_info->direction);
987 BT_DBG(" status = [%d]", call_info->status);
988 BT_DBG(" mpart = [%d]", call_info->mpart);
989 BT_DBG(" number = [%s]", call_info->number);
990 BT_DBG(" idx = [%d]", call_info->idx);
991 call_status[i] = call_info;
994 return BLUETOOTH_ERROR_NONE;
997 BT_EXPORT_API int bluetooth_hf_free_call_list(bt_hf_call_list_s *call_list)
999 bt_hf_call_list_s *handle;
1000 bt_hf_call_status_info_t *call_status;
1002 retv_if(call_list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1004 handle = (bt_hf_call_list_s *)call_list;
1006 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(
1008 if (call_status == NULL)
1010 handle->list = g_list_remove(handle->list, call_status);
1011 g_free(call_status->number);
1012 g_free(call_status);
1015 return BLUETOOTH_ERROR_NONE;
1018 BT_EXPORT_API int bluetooth_hf_request_call_list(
1019 bt_hf_call_list_s **call_list)
1021 GVariant *reply = NULL;
1024 BT_CHECK_ENABLED(return);
1026 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1027 "RequestCallList", &err, NULL);
1029 BT_ERR("dbus Error or call list is null\n");
1031 BT_ERR("Error = %s", err->message);
1032 g_clear_error(&err);
1035 return BLUETOOTH_ERROR_INTERNAL;
1037 __bt_hf_agent_read_call_list(reply, call_list);
1039 g_variant_unref(reply);
1040 return BLUETOOTH_ERROR_NONE;
1043 BT_EXPORT_API int bluetooth_hf_get_codec(unsigned int *codec_id)
1045 GVariant *reply = NULL;
1047 int32_t current_codec;
1049 BT_CHECK_ENABLED(return);
1051 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1052 "GetCurrentCodec", &err, NULL);
1054 BT_ERR("Error returned in method call\n");
1056 BT_ERR("Error = %s", err->message);
1057 g_clear_error(&err);
1059 return BLUETOOTH_ERROR_INTERNAL;
1062 g_variant_get(reply, "(i)", ¤t_codec);
1063 *codec_id = current_codec;
1064 BT_DBG(" Codec ID is : %d", *codec_id);
1066 g_variant_unref(reply);
1067 return BLUETOOTH_ERROR_NONE;
1070 BT_EXPORT_API int bluetooth_hf_get_audio_connected(unsigned int *audio_connected)
1072 GVariant *reply = NULL;
1074 int32_t sco_audio_connected_from_bt_agent;
1076 BT_CHECK_ENABLED(return);
1078 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1079 "GetAudioConnected", &err, NULL);
1081 BT_ERR("Error returned in method call\n");
1083 BT_ERR("Error = %s", err->message);
1084 g_clear_error(&err);
1086 return BLUETOOTH_ERROR_INTERNAL;
1089 g_variant_get(reply, "(i)", &sco_audio_connected_from_bt_agent);
1090 *audio_connected = sco_audio_connected_from_bt_agent;
1092 if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED) {
1093 BT_DBG("SCO Audio is Connected");
1095 BT_DBG("SCO Audio is Disconnected");
1098 g_variant_unref(reply);
1099 return BLUETOOTH_ERROR_NONE;
1102 BT_EXPORT_API int bluetooth_hf_is_connected(gboolean *hf_connected)
1104 GVariant *reply = NULL;
1106 gboolean hf_connected_from_bt_agent;
1108 BT_CHECK_ENABLED(return);
1110 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1111 "IsHfConnected", &err, NULL);
1113 BT_ERR("Error returned in method call\n");
1115 BT_ERR("Error = %s", err->message);
1116 g_clear_error(&err);
1118 return BLUETOOTH_ERROR_INTERNAL;
1121 g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
1122 *hf_connected = hf_connected_from_bt_agent;
1124 BT_DBG("%s", *hf_connected ? "Connected" : "Disconnected");
1126 g_variant_unref(reply);
1127 return BLUETOOTH_ERROR_NONE;
1130 BT_EXPORT_API int bluetooth_hf_is_ibr_supported(gboolean *ibr_supported)
1132 GVariant *reply = NULL;
1134 gboolean is_supported;
1135 int ret = BLUETOOTH_ERROR_NONE;
1137 BT_CHECK_ENABLED(return);
1139 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1140 "IsInbandRingtoneSupported", &err, NULL);
1142 BT_ERR("Error returned in method call");
1144 g_dbus_error_strip_remote_error(err);
1145 ret = __bluetooth_hf_get_error(err->message);
1149 return BLUETOOTH_ERROR_INTERNAL;
1152 g_variant_get(reply, "(b)", &is_supported);
1153 *ibr_supported = is_supported;
1155 BT_DBG("%s", *ibr_supported ? "Supported" : "Not Supported");
1157 g_variant_unref(reply);