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
32 BT_EXPORT_API int bluetooth_audio_init(bt_audio_func_ptr cb, void *user_data)
37 BT_ERR("callback is NULL");
38 return BLUETOOTH_ERROR_INVALID_PARAM;
40 ret = _bt_init_event_handler();
42 if (ret != BLUETOOTH_ERROR_NONE &&
43 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
44 BT_ERR("Fail to init the event handler");
48 _bt_set_user_data(BT_AUDIO, (void *)cb, user_data);
50 /* Register All events */
51 ret = _bt_register_event(BT_HEADSET_EVENT, (void *)cb, user_data);
52 if (ret != BLUETOOTH_ERROR_NONE &&
53 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
54 _bt_deinit_event_handler();
58 ret = _bt_register_event(BT_A2DP_SOURCE_EVENT, (void *)cb, user_data);
59 if (ret != BLUETOOTH_ERROR_NONE &&
60 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
61 _bt_deinit_event_handler();
65 return BLUETOOTH_ERROR_NONE;
68 BT_EXPORT_API int bluetooth_audio_deinit(void)
70 _bt_unregister_event(BT_HEADSET_EVENT);
71 _bt_unregister_event(BT_A2DP_SOURCE_EVENT);
72 _bt_set_user_data(BT_AUDIO, NULL, NULL);
74 return BLUETOOTH_ERROR_NONE;
77 BT_EXPORT_API int bluetooth_audio_connect(bluetooth_device_address_t *remote_address)
79 int service_function = BT_AUDIO_CONNECT;
81 bt_user_info_t *user_info;
83 BT_CHECK_PARAMETER(remote_address, return);
84 BT_CHECK_ENABLED(return);
86 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_CONNECT)
87 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
88 BT_ERR("Don't have a privilege to use this API");
89 return BLUETOOTH_ERROR_PERMISSION_DEINED;
92 #ifdef TIZEN_DPM_ENABLE
93 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
94 BT_ERR("Blacklist device");
95 return BLUETOOTH_ERROR_ACCESS_DENIED;
98 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED &&
99 _bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
100 BT_ERR("Not allow to use HSP / A2DP profile");
101 return BLUETOOTH_ERROR_ACCESS_DENIED;
102 } else if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
103 BT_ERR("Not allow to use HSP profile");
104 service_function = BT_AV_CONNECT;
105 } else if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
106 BT_ERR("Not allow to use A2DP profile");
107 service_function = BT_AG_CONNECT;
110 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
111 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
112 bluetooth_device_class_t dev_class;
114 _bt_convert_addr_type_to_string(address, remote_address->addr);
115 _bt_get_cod_by_address(address, &dev_class);
117 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
118 BT_ERR("Reject a authorization due to MDM Policy");
119 return BLUETOOTH_ERROR_ACCESS_DENIED;
124 user_info = _bt_get_user_data(BT_AUDIO);
125 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
128 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
130 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
132 result = _bt_send_request_async(BT_BLUEZ_SERVICE, service_function,
133 in_param1, in_param2, in_param3, in_param4,
134 user_info->cb, user_info->user_data);
136 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
141 BT_EXPORT_API int bluetooth_audio_disconnect(bluetooth_device_address_t *remote_address)
144 bt_user_info_t *user_info;
146 BT_CHECK_PARAMETER(remote_address, return);
147 BT_CHECK_ENABLED(return);
149 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_DISCONNECT)
150 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
151 BT_ERR("Don't have a privilege to use this API");
152 return BLUETOOTH_ERROR_PERMISSION_DEINED;
155 user_info = _bt_get_user_data(BT_AUDIO);
156 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
159 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
161 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
163 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_DISCONNECT,
164 in_param1, in_param2, in_param3, in_param4,
165 user_info->cb, user_info->user_data);
167 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
172 BT_EXPORT_API int bluetooth_ag_connect(bluetooth_device_address_t *remote_address)
175 bt_user_info_t *user_info;
177 BT_CHECK_PARAMETER(remote_address, return);
178 BT_CHECK_ENABLED(return);
180 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_CONNECT)
181 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
182 BT_ERR("Don't have a privilege to use this API");
183 return BLUETOOTH_ERROR_PERMISSION_DEINED;
186 #ifdef TIZEN_DPM_ENABLE
187 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
188 BT_ERR("Blacklist device");
189 return BLUETOOTH_ERROR_ACCESS_DENIED;
192 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
193 BT_ERR("Not allow to use HSP profile");
194 return BLUETOOTH_ERROR_ACCESS_DENIED;
197 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
198 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
199 bluetooth_device_class_t dev_class;
201 _bt_convert_addr_type_to_string(address, remote_address->addr);
202 _bt_get_cod_by_address(address, &dev_class);
204 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
205 BT_ERR("Reject a authorization due to MDM Policy");
206 return BLUETOOTH_ERROR_ACCESS_DENIED;
211 user_info = _bt_get_user_data(BT_AUDIO);
212 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
215 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
217 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
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_ACCESS_DENIED;
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_ACCESS_DENIED;
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_ACCESS_DENIED;
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_ACCESS_DENIED;
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_ACCESS_DENIED;
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_ACCESS_DENIED;;
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 BT_EXPORT_API int bluetooth_hf_init(bt_hf_func_ptr cb, void *user_data)
549 BT_ERR("callback is NULL");
550 return BLUETOOTH_ERROR_INVALID_PARAM;
553 ret = _bt_init_event_handler();
555 if (ret != BLUETOOTH_ERROR_NONE &&
556 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
557 BT_ERR("Fail to init the event handler");
561 _bt_set_user_data(BT_HF, (void *)cb, user_data);
563 /* Register All events */
564 ret = _bt_register_event(BT_HF_AGENT_EVENT, (void *)cb, user_data);
565 if (ret != BLUETOOTH_ERROR_NONE &&
566 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
567 _bt_deinit_event_handler();
571 return BLUETOOTH_ERROR_NONE;
574 BT_EXPORT_API int bluetooth_hf_deinit(void)
578 ret = _bt_unregister_event(BT_HF_AGENT_EVENT);
579 if (ret != BLUETOOTH_ERROR_NONE )
580 BT_ERR("_bt_unregister_event failed");
582 _bt_set_user_data(BT_HF, NULL, NULL);
584 return BLUETOOTH_ERROR_NONE;
587 BT_EXPORT_API int bluetooth_hf_connect(bluetooth_device_address_t *remote_address)
590 bt_user_info_t *user_info;
592 BT_CHECK_ENABLED(return);
593 BT_CHECK_PARAMETER(remote_address, return);
595 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_CONNECT)
596 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
597 BT_ERR("Don't have a privilege to use this API");
598 return BLUETOOTH_ERROR_PERMISSION_DEINED;
601 user_info = _bt_get_user_data(BT_HF);
602 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
605 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
607 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
609 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_CONNECT,
610 in_param1, in_param2, in_param3, in_param4,
611 user_info->cb, user_info->user_data);
613 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
618 BT_EXPORT_API int bluetooth_hf_disconnect(bluetooth_device_address_t *remote_address)
621 bt_user_info_t *user_info;
623 BT_CHECK_PARAMETER(remote_address, return);
624 BT_CHECK_ENABLED(return);
626 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_DISCONNECT)
627 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
628 BT_ERR("Don't have a privilege to use this API");
629 return BLUETOOTH_ERROR_PERMISSION_DEINED;
632 user_info = _bt_get_user_data(BT_HF);
633 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
636 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
638 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
640 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_DISCONNECT,
641 in_param1, in_param2, in_param3, in_param4,
642 user_info->cb, user_info->user_data);
644 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
649 BT_EXPORT_API int bluetooth_hf_answer_call()
651 GVariant *reply = NULL;
653 int ret = BLUETOOTH_ERROR_INTERNAL;
655 BT_CHECK_ENABLED(return);
657 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
658 "AnswerCall", &err, NULL);
660 BT_ERR("Error returned in method call\n");
662 BT_ERR("Error = %s", err->message);
663 g_dbus_error_strip_remote_error(err);
664 if (strcmp(err->message, "Operation not supported") == 0)
665 ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
666 else if (strcmp(err->message, "Operation not allowed") == 0)
667 ret = BLUETOOTH_ERROR_PERMISSION_DEINED;
669 ret = BLUETOOTH_ERROR_INTERNAL;
675 g_variant_unref(reply);
676 return BLUETOOTH_ERROR_NONE;
680 BT_EXPORT_API int bluetooth_hf_terminate_call()
682 GVariant *reply = NULL;
685 BT_CHECK_ENABLED(return);
687 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
688 "TerminateCall", &err, NULL);
690 BT_ERR("Error returned in method call\n");
692 BT_ERR("Error = %s", err->message);
695 return BLUETOOTH_ERROR_INTERNAL;
698 g_variant_unref(reply);
699 return BLUETOOTH_ERROR_NONE;
702 BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
704 GVariant *reply = NULL;
706 GVariant *param = NULL;
707 int ret = BLUETOOTH_ERROR_INTERNAL;
709 BT_CHECK_ENABLED(return);
714 param = g_variant_new("(s)", number);
715 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
716 "InitiateCall", &err, param);
718 BT_ERR("Error returned in method call");
720 BT_ERR("Error = %s", err->message);
721 g_dbus_error_strip_remote_error(err);
722 if (strcmp(err->message, "NotConnected") == 0)
723 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
724 else if (strcmp(err->message, "Operation not allowed") == 0)
725 ret = BLUETOOTH_ERROR_IN_PROGRESS;
727 ret = BLUETOOTH_ERROR_INTERNAL;
733 g_variant_unref(reply);
734 return BLUETOOTH_ERROR_NONE;
737 BT_EXPORT_API int bluetooth_hf_voice_recognition(unsigned int status)
739 GVariant *reply = NULL;
741 GVariant *param = NULL;
743 BT_CHECK_ENABLED(return);
745 param = g_variant_new("(i)", status);
746 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
747 "VoiceRecognition", &err, param);
749 BT_ERR("Error returned in method call\n");
751 BT_ERR("Error = %s", err->message);
754 return BLUETOOTH_ERROR_INTERNAL;
757 g_variant_unref(reply);
758 return BLUETOOTH_ERROR_NONE;
761 BT_EXPORT_API int bluetooth_hf_audio_disconnect(void)
763 GVariant *reply = NULL;
766 BT_CHECK_ENABLED(return);
768 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
769 "ScoDisconnect", &err, NULL);
771 BT_ERR("Error returned in method call\n");
773 BT_ERR("Error = %s", err->message);
776 return BLUETOOTH_ERROR_INTERNAL;
779 g_variant_unref(reply);
780 return BLUETOOTH_ERROR_NONE;
783 BT_EXPORT_API int bluetooth_hf_set_speaker_gain(unsigned int speaker_gain)
785 GVariant *reply = NULL;
787 GVariant *param = NULL;
789 BT_CHECK_ENABLED(return);
791 param = g_variant_new("(u)", speaker_gain);
792 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
793 "SpeakerGain", &err, param);
795 BT_ERR("Error returned in method call\n");
797 BT_ERR("Error = %s", err->message);
800 return BLUETOOTH_ERROR_INTERNAL;
803 g_variant_unref(reply);
804 return BLUETOOTH_ERROR_NONE;
807 BT_EXPORT_API int bluetooth_hf_send_dtmf(char *dtmf)
809 GVariant *reply = NULL;
811 GVariant *param = NULL;
813 BT_CHECK_ENABLED(return);
815 param = g_variant_new("(s)", dtmf);
816 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
817 "SendDtmf", &err, param);
819 BT_ERR("Error returned in method call\n");
821 BT_ERR("Error = %s", err->message);
824 return BLUETOOTH_ERROR_INTERNAL;
827 g_variant_unref(reply);
828 return BLUETOOTH_ERROR_NONE;
831 BT_EXPORT_API int bluetooth_hf_send_xsat_cmd(int app_id, char *xsat_cmd)
833 GVariant *reply = NULL;
835 GVariant *param = NULL;
836 char buffer[200] = {0,};
839 BT_CHECK_ENABLED(return);
841 strncpy(buffer, "AT+XSAT=", strlen("AT+XSAT="));
842 snprintf(buffer + strlen(buffer), sizeof(buffer), "%d,", app_id);
843 strncat(buffer, xsat_cmd, (sizeof(buffer) - 1) - strlen(buffer));
844 BT_DBG("Xsat cmd received = %s", buffer);
846 param = g_variant_new("(s)", ptr);
848 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
849 "SendAtCmd", &err, param);
851 BT_ERR("Error returned in method call\n");
853 BT_ERR("Error = %s", err->message);
856 return BLUETOOTH_ERROR_INTERNAL;
859 g_variant_unref(reply);
860 return BLUETOOTH_ERROR_NONE;
863 BT_EXPORT_API int bluetooth_hf_release_and_accept(void)
865 GVariant *reply = NULL;
868 BT_CHECK_ENABLED(return);
870 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
871 "ReleaseAndAccept", &err, NULL);
873 BT_ERR("Error returned in method call\n");
875 BT_ERR("Error = %s", err->message);
878 return BLUETOOTH_ERROR_INTERNAL;
881 g_variant_unref(reply);
882 return BLUETOOTH_ERROR_NONE;
885 BT_EXPORT_API int bluetooth_hf_swap_call(void)
887 GVariant *reply = NULL;
890 BT_CHECK_ENABLED(return);
892 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
893 "CallSwap", &err, NULL);
895 BT_ERR("Error returned in method call\n");
897 BT_ERR("Error = %s", err->message);
900 return BLUETOOTH_ERROR_INTERNAL;
903 g_variant_unref(reply);
904 return BLUETOOTH_ERROR_NONE;
907 BT_EXPORT_API int bluetooth_hf_release_all_call(void)
909 GVariant *reply = NULL;
912 BT_CHECK_ENABLED(return);
914 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
915 "ReleaseAllCall", &err, NULL);
917 BT_ERR("Error returned in method call\n");
919 BT_ERR("Error = %s", err->message);
922 return BLUETOOTH_ERROR_INTERNAL;
925 g_variant_unref(reply);
926 return BLUETOOTH_ERROR_NONE;
929 BT_EXPORT_API int bluetooth_hf_join_call(void)
931 GVariant *reply = NULL;
934 BT_CHECK_ENABLED(return);
936 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
937 "JoinCall", &err, NULL);
939 BT_ERR("Error returned in method call\n");
941 BT_ERR("Error = %s", err->message);
944 return BLUETOOTH_ERROR_INTERNAL;
947 g_variant_unref(reply);
948 return BLUETOOTH_ERROR_NONE;
951 BT_EXPORT_API int bluetooth_hf_get_call_list(void *call_list,
952 bt_hf_call_status_info_t **call_status)
955 GList *list = call_list;
957 bt_hf_call_status_info_t * call_info;
959 BT_CHECK_ENABLED(return);
960 retv_if(list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
961 retv_if(call_status == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
963 call_count = g_list_length(list);
965 BT_DBG(" call_count = [%d]", call_count);
967 for (i = 0; i < call_count; i++) {
968 call_info = g_list_nth_data(list, i);
969 BT_DBG(" direction = [%d]", call_info->direction);
970 BT_DBG(" status = [%d]", call_info->status);
971 BT_DBG(" mpart = [%d]", call_info->mpart);
972 BT_DBG(" number = [%s]", call_info->number);
973 BT_DBG(" idx = [%d]", call_info->idx);
974 call_status[i] = call_info;
977 return BLUETOOTH_ERROR_NONE;
980 BT_EXPORT_API int bluetooth_hf_free_call_list(bt_hf_call_list_s *call_list)
982 bt_hf_call_list_s *handle;
983 bt_hf_call_status_info_t *call_status;
985 retv_if(call_list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
987 handle = (bt_hf_call_list_s *)call_list;
989 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(
991 if (call_status == NULL)
993 handle->list = g_list_remove(handle->list, call_status);
994 g_free(call_status->number);
998 return BLUETOOTH_ERROR_NONE;
1001 BT_EXPORT_API int bluetooth_hf_request_call_list(
1002 bt_hf_call_list_s **call_list)
1004 GVariant *reply = NULL;
1007 BT_CHECK_ENABLED(return);
1009 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1010 "RequestCallList", &err, NULL);
1012 BT_ERR("dbus Error or call list is null\n");
1014 BT_ERR("Error = %s", err->message);
1015 g_clear_error(&err);
1018 return BLUETOOTH_ERROR_INTERNAL;
1020 __bt_hf_agent_read_call_list(reply, call_list);
1022 g_variant_unref(reply);
1023 return BLUETOOTH_ERROR_NONE;
1026 BT_EXPORT_API int bluetooth_hf_get_codec(unsigned int *codec_id)
1028 GVariant *reply = NULL;
1030 int32_t current_codec;
1032 BT_CHECK_ENABLED(return);
1034 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1035 "GetCurrentCodec", &err, NULL);
1037 BT_ERR("Error returned in method call\n");
1039 BT_ERR("Error = %s", err->message);
1040 g_clear_error(&err);
1042 return BLUETOOTH_ERROR_INTERNAL;
1045 g_variant_get(reply, "(i)", ¤t_codec);
1046 *codec_id = current_codec;
1047 BT_DBG(" Codec ID is : %d", *codec_id);
1049 g_variant_unref(reply);
1050 return BLUETOOTH_ERROR_NONE;
1053 BT_EXPORT_API int bluetooth_hf_get_audio_connected(unsigned int *audio_connected)
1055 GVariant *reply = NULL;
1057 int32_t sco_audio_connected_from_bt_agent;
1059 BT_CHECK_ENABLED(return);
1061 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1062 "GetAudioConnected", &err, NULL);
1064 BT_ERR("Error returned in method call\n");
1066 BT_ERR("Error = %s", err->message);
1067 g_clear_error(&err);
1069 return BLUETOOTH_ERROR_INTERNAL;
1072 g_variant_get(reply, "(i)", &sco_audio_connected_from_bt_agent);
1073 *audio_connected = sco_audio_connected_from_bt_agent;
1075 if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED) {
1076 BT_DBG("SCO Audio is Connected");
1078 BT_DBG("SCO Audio is Disconnected");
1081 g_variant_unref(reply);
1082 return BLUETOOTH_ERROR_NONE;
1085 BT_EXPORT_API int bluetooth_hf_is_connected(gboolean *hf_connected)
1087 GVariant *reply = NULL;
1089 gboolean hf_connected_from_bt_agent;
1091 BT_CHECK_ENABLED(return);
1093 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1094 "IsHfConnected", &err, NULL);
1096 BT_ERR("Error returned in method call\n");
1098 BT_ERR("Error = %s", err->message);
1099 g_clear_error(&err);
1101 return BLUETOOTH_ERROR_INTERNAL;
1104 g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
1105 *hf_connected = hf_connected_from_bt_agent;
1107 BT_DBG("%s", *hf_connected ? "Connected":"Disconnected");
1109 g_variant_unref(reply);
1110 return BLUETOOTH_ERROR_NONE;