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_FEATURE_BT_DPM
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_FEATURE_BT_DPM
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 #ifdef TIZEN_FEATURE_BT_DPM
132 if (service_function == BT_AV_CONNECT)
133 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
134 in_param1, in_param2, in_param3, in_param4,
135 user_info->cb, user_info->user_data);
136 else if (service_function == BT_AG_CONNECT)
137 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
138 in_param1, in_param2, in_param3, in_param4,
139 user_info->cb, user_info->user_data);
140 else /* default case - with or without DPM enabled */
142 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_CONNECT,
143 in_param1, in_param2, in_param3, in_param4,
144 user_info->cb, user_info->user_data);
146 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
151 BT_EXPORT_API int bluetooth_audio_disconnect(bluetooth_device_address_t *remote_address)
154 bt_user_info_t *user_info;
156 BT_CHECK_PARAMETER(remote_address, return);
157 BT_CHECK_ENABLED(return);
159 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_DISCONNECT)
160 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
161 BT_ERR("Don't have a privilege to use this API");
162 return BLUETOOTH_ERROR_PERMISSION_DEINED;
165 user_info = _bt_get_user_data(BT_AUDIO);
166 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
169 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
171 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
173 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_DISCONNECT,
174 in_param1, in_param2, in_param3, in_param4,
175 user_info->cb, user_info->user_data);
177 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
182 BT_EXPORT_API int bluetooth_ag_connect(bluetooth_device_address_t *remote_address)
185 bt_user_info_t *user_info;
187 BT_CHECK_PARAMETER(remote_address, return);
188 BT_CHECK_ENABLED(return);
190 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_CONNECT)
191 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
192 BT_ERR("Don't have a privilege to use this API");
193 return BLUETOOTH_ERROR_PERMISSION_DEINED;
196 #ifdef TIZEN_FEATURE_BT_DPM
197 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
198 BT_ERR("Blacklist device");
199 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
202 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
203 BT_ERR("Not allow to use HSP profile");
204 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
207 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
208 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
209 bluetooth_device_class_t dev_class;
211 _bt_convert_addr_type_to_string(address, remote_address->addr);
212 _bt_get_cod_by_address(address, &dev_class);
214 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
215 BT_ERR("Reject a authorization due to MDM Policy");
216 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
221 user_info = _bt_get_user_data(BT_AUDIO);
222 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
225 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
227 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
229 BT_INFO_C("### Connect AG");
230 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
231 in_param1, in_param2, in_param3, in_param4,
232 user_info->cb, user_info->user_data);
234 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
239 BT_EXPORT_API int bluetooth_ag_disconnect(bluetooth_device_address_t *remote_address)
242 bt_user_info_t *user_info;
244 BT_CHECK_PARAMETER(remote_address, return);
245 BT_CHECK_ENABLED(return);
247 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_DISCONNECT)
248 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
249 BT_ERR("Don't have a privilege to use this API");
250 return BLUETOOTH_ERROR_PERMISSION_DEINED;
253 user_info = _bt_get_user_data(BT_AUDIO);
254 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
257 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
259 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
261 BT_INFO_C("### Disconnect AG");
262 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_DISCONNECT,
263 in_param1, in_param2, in_param3, in_param4,
264 user_info->cb, user_info->user_data);
266 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
271 BT_EXPORT_API int bluetooth_av_connect(bluetooth_device_address_t *remote_address)
274 bt_user_info_t *user_info;
276 BT_CHECK_PARAMETER(remote_address, return);
277 BT_CHECK_ENABLED(return);
279 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_CONNECT)
280 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
281 BT_ERR("Don't have a privilege to use this API");
282 return BLUETOOTH_ERROR_PERMISSION_DEINED;
285 #ifdef TIZEN_FEATURE_BT_DPM
286 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
287 BT_ERR("Blacklist device");
288 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
291 if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
292 BT_ERR("Not allow to use A2DP profile");
293 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
296 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
297 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
298 bluetooth_device_class_t dev_class;
300 _bt_convert_addr_type_to_string(address, remote_address->addr);
301 _bt_get_cod_by_address(address, &dev_class);
303 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
304 BT_ERR("Reject a authorization due to MDM Policy");
305 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
310 user_info = _bt_get_user_data(BT_AUDIO);
311 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
314 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
316 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
318 BT_INFO_C("### Connect AV");
319 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
320 in_param1, in_param2, in_param3, in_param4,
321 user_info->cb, user_info->user_data);
323 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
328 BT_EXPORT_API int bluetooth_av_source_connect(bluetooth_device_address_t *remote_address)
331 bt_user_info_t *user_info;
333 BT_CHECK_PARAMETER(remote_address, return);
334 BT_CHECK_ENABLED(return);
336 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_CONNECT)
337 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
338 BT_ERR("Don't have a privilege to use this API");
339 return BLUETOOTH_ERROR_PERMISSION_DEINED;
342 #ifdef TIZEN_FEATURE_BT_DPM
343 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
344 BT_ERR("Blacklist device");
345 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
348 if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
349 BT_ERR("Not allow to use A2DP profile");
350 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
354 user_info = _bt_get_user_data(BT_AUDIO);
355 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
358 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
360 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
362 BT_INFO_C("### Connect AV Source");
363 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_CONNECT,
364 in_param1, in_param2, in_param3, in_param4,
365 user_info->cb, user_info->user_data);
367 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
372 BT_EXPORT_API int bluetooth_av_disconnect(bluetooth_device_address_t *remote_address)
375 bt_user_info_t *user_info;
377 BT_CHECK_PARAMETER(remote_address, return);
378 BT_CHECK_ENABLED(return);
380 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_DISCONNECT)
381 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
382 BT_ERR("Don't have a privilege to use this API");
383 return BLUETOOTH_ERROR_PERMISSION_DEINED;
386 user_info = _bt_get_user_data(BT_AUDIO);
387 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
390 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
392 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
394 BT_INFO_C("### Disconnect AV");
395 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_DISCONNECT,
396 in_param1, in_param2, in_param3, in_param4,
397 user_info->cb, user_info->user_data);
399 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
404 BT_EXPORT_API int bluetooth_av_source_disconnect(bluetooth_device_address_t *remote_address)
407 bt_user_info_t *user_info;
409 BT_CHECK_PARAMETER(remote_address, return);
410 BT_CHECK_ENABLED(return);
412 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_DISCONNECT)
413 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
414 BT_ERR("Don't have a privilege to use this API");
415 return BLUETOOTH_ERROR_PERMISSION_DEINED;
418 user_info = _bt_get_user_data(BT_AUDIO);
419 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
422 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
424 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
426 BT_INFO_C("### Disconnect AV Source");
427 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_DISCONNECT,
428 in_param1, in_param2, in_param3, in_param4,
429 user_info->cb, user_info->user_data);
431 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
436 BT_EXPORT_API int bluetooth_audio_select_role(bluetooth_audio_role_t role)
440 BT_CHECK_ENABLED(return);
443 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
445 g_array_append_vals(in_param1, &role, sizeof(bluetooth_audio_role_t));
447 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_SELECT_ROLE,
448 in_param1, in_param2, in_param3, in_param4, &out_param);
450 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
454 BT_EXPORT_API int bluetooth_audio_set_absolute_volume(unsigned int volume)
458 BT_CHECK_ENABLED(return);
461 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
463 g_array_append_vals(in_param1, &volume, sizeof(unsigned int));
465 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_SET_ABSOLUTE_VOLUME,
466 in_param1, in_param2, in_param3, in_param4, &out_param);
468 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
472 BT_EXPORT_API int bluetooth_audio_get_absolute_volume(unsigned int *volume)
476 BT_CHECK_PARAMETER(volume, return);
477 BT_CHECK_ENABLED(return);
480 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
482 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_GET_ABSOLUTE_VOLUME,
483 in_param1, in_param2, in_param3, in_param4, &out_param);
485 if (result == BLUETOOTH_ERROR_NONE) {
486 *volume = g_array_index(out_param,
490 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
495 BT_EXPORT_API int bluetooth_audio_is_avc_activated(bool *activated)
499 BT_CHECK_PARAMETER(activated, return);
501 if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_DISABLED) {
502 BT_DBG("BT is not enabled. So activated value is false");
504 return BLUETOOTH_ERROR_NONE;
508 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
510 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_IS_AVC_ACTIVATED,
511 in_param1, in_param2, in_param3, in_param4, &out_param);
513 if (result == BLUETOOTH_ERROR_NONE) {
514 *activated = g_array_index(out_param,
518 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
523 BT_EXPORT_API int bluetooth_ag_get_headset_volume(unsigned int *speaker_gain)
527 BT_CHECK_PARAMETER(speaker_gain, return);
528 BT_CHECK_ENABLED(return);
531 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
533 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SPEAKER_GAIN,
534 in_param1, in_param2, in_param3, in_param4, &out_param);
536 if (result == BLUETOOTH_ERROR_NONE) {
537 *speaker_gain = g_array_index(out_param,
541 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
546 BT_EXPORT_API int bluetooth_ag_set_speaker_gain(unsigned int speaker_gain)
550 BT_CHECK_ENABLED(return);
552 #ifdef TIZEN_FEATURE_BT_DPM
553 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
554 BT_ERR("Not allow to use HSP profile");
555 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
560 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
562 g_array_append_vals(in_param1, &speaker_gain, sizeof(unsigned int));
564 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SPEAKER_GAIN,
565 in_param1, in_param2, in_param3, in_param4, &out_param);
567 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
572 #define BT_HF_SERVICE_NAME "org.bluez.hf_agent"
573 #define BT_HF_OBJECT_PATH "/org/bluez/handsfree_agent"
574 #define BT_HF_INTERFACE "org.tizen.HfApp"
577 static GVariant* __bt_hf_agent_dbus_send(const char *path, const char *interface,
578 const char *method, GError **err, GVariant *parameters)
580 GVariant *reply = NULL;
581 GDBusProxy *proxy = NULL;
582 GDBusConnection *conn = NULL;
584 conn = _bt_get_system_private_conn();
585 retv_if(conn == NULL, NULL);
587 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
588 NULL, BT_HF_SERVICE_NAME, path, interface, NULL, err);
590 BT_ERR("Unable to allocate new proxy");
594 reply = g_dbus_proxy_call_sync(proxy, method, parameters,
595 G_DBUS_CALL_FLAGS_NONE, -1, NULL, err);
597 g_object_unref(proxy);
601 static int __bt_hf_agent_read_call_list(GVariant *reply,
602 bt_hf_call_list_s **call_list) {
605 GVariant *var_temp = NULL;
608 int dir, status, mpart, idx;
612 g_variant_get(reply, "(i@a(siiii))", &call_count, &var_temp);
614 if (call_count <= 0) {
616 return BLUETOOTH_ERROR_NOT_FOUND;
618 BT_DBG("Call count = %d", call_count);
620 *call_list = g_malloc0(sizeof(bt_hf_call_list_s));
621 (*call_list)->count = call_count;
623 g_variant_iter_init(&iter, var_temp);
624 while (g_variant_iter_loop(&iter, "(siiii)", &num, &dir, &status, &mpart, &idx)) {
625 bt_hf_call_status_info_t *call_info;
627 call_info = g_malloc0(sizeof(bt_hf_call_status_info_t));
628 call_info->number = g_strdup(num);
629 call_info->direction = dir;
630 call_info->status = status;
631 call_info->mpart = mpart;
632 call_info->idx = idx;
634 (*call_list)->list = g_list_append((*call_list)->list,
635 (gpointer)call_info);
638 g_variant_unref(var_temp);
640 return BLUETOOTH_ERROR_NONE;
643 static int __bluetooth_hf_get_error(const char *error_message)
645 if (error_message == NULL) {
646 BT_ERR("Error message NULL");
647 return BLUETOOTH_ERROR_INTERNAL;
650 BT_ERR("Error message = %s", error_message);
652 if (g_strcmp0(error_message, "NotConnected") == 0)
653 return BLUETOOTH_ERROR_NOT_CONNECTED;
655 return BLUETOOTH_ERROR_INTERNAL;
658 BT_EXPORT_API int bluetooth_hf_init(bt_hf_func_ptr cb, void *user_data)
663 BT_ERR("callback is NULL");
664 return BLUETOOTH_ERROR_INVALID_PARAM;
667 ret = _bt_init_event_handler();
669 if (ret != BLUETOOTH_ERROR_NONE &&
670 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
671 BT_ERR("Fail to init the event handler");
675 _bt_set_user_data(BT_HF, (void *)cb, user_data);
677 /* Register All events */
678 ret = _bt_register_event(BT_HF_AGENT_EVENT, (void *)cb, user_data);
679 if (ret != BLUETOOTH_ERROR_NONE &&
680 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
681 _bt_deinit_event_handler();
685 return BLUETOOTH_ERROR_NONE;
688 BT_EXPORT_API int bluetooth_hf_deinit(void)
692 ret = _bt_unregister_event(BT_HF_AGENT_EVENT);
693 if (ret != BLUETOOTH_ERROR_NONE)
694 BT_ERR("_bt_unregister_event failed");
696 _bt_set_user_data(BT_HF, NULL, NULL);
698 return BLUETOOTH_ERROR_NONE;
701 BT_EXPORT_API int bluetooth_hf_connect(bluetooth_device_address_t *remote_address)
704 bt_user_info_t *user_info;
706 BT_CHECK_ENABLED(return);
707 BT_CHECK_PARAMETER(remote_address, return);
709 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_CONNECT)
710 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
711 BT_ERR("Don't have a privilege to use this API");
712 return BLUETOOTH_ERROR_PERMISSION_DEINED;
715 user_info = _bt_get_user_data(BT_HF);
716 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
719 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
721 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
723 BT_INFO_C("### Connect HF");
724 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_CONNECT,
725 in_param1, in_param2, in_param3, in_param4,
726 user_info->cb, user_info->user_data);
728 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
733 BT_EXPORT_API int bluetooth_hf_disconnect(bluetooth_device_address_t *remote_address)
736 bt_user_info_t *user_info;
738 BT_CHECK_PARAMETER(remote_address, return);
739 BT_CHECK_ENABLED(return);
741 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_DISCONNECT)
742 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
743 BT_ERR("Don't have a privilege to use this API");
744 return BLUETOOTH_ERROR_PERMISSION_DEINED;
747 user_info = _bt_get_user_data(BT_HF);
748 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
751 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
753 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
755 BT_INFO_C("### Disconnect HF");
756 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_DISCONNECT,
757 in_param1, in_param2, in_param3, in_param4,
758 user_info->cb, user_info->user_data);
760 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
765 BT_EXPORT_API int bluetooth_hf_answer_call()
767 GVariant *reply = NULL;
769 int ret = BLUETOOTH_ERROR_INTERNAL;
771 BT_CHECK_ENABLED(return);
773 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
774 "AnswerCall", &err, NULL);
776 BT_ERR("Error returned in method call\n");
778 BT_ERR("Error = %s", err->message);
779 g_dbus_error_strip_remote_error(err);
780 ret = _bt_get_error_value_from_message(err->message);
786 g_variant_unref(reply);
787 return BLUETOOTH_ERROR_NONE;
791 BT_EXPORT_API int bluetooth_hf_terminate_call()
793 GVariant *reply = NULL;
795 int ret = BLUETOOTH_ERROR_INTERNAL;
797 BT_CHECK_ENABLED(return);
799 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
800 "TerminateCall", &err, NULL);
802 BT_ERR("Error returned in method call\n");
804 BT_ERR("Error = %s", err->message);
805 g_dbus_error_strip_remote_error(err);
806 ret = _bt_get_error_value_from_message(err->message);
812 g_variant_unref(reply);
813 return BLUETOOTH_ERROR_NONE;
816 BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
818 GVariant *reply = NULL;
820 GVariant *param = NULL;
821 int ret = BLUETOOTH_ERROR_INTERNAL;
823 BT_CHECK_ENABLED(return);
828 param = g_variant_new("(s)", number);
829 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
830 "InitiateCall", &err, param);
832 BT_ERR("Error returned in method call");
834 BT_ERR("Error = %s", err->message);
835 g_dbus_error_strip_remote_error(err);
836 ret = _bt_get_error_value_from_message(err->message);
842 g_variant_unref(reply);
843 return BLUETOOTH_ERROR_NONE;
846 BT_EXPORT_API int bluetooth_hf_voice_recognition(unsigned int status)
848 GVariant *reply = NULL;
850 GVariant *param = NULL;
851 int ret = BLUETOOTH_ERROR_INTERNAL;
853 BT_CHECK_ENABLED(return);
855 param = g_variant_new("(i)", status);
856 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
857 "VoiceRecognition", &err, param);
859 BT_ERR("Error returned in method call\n");
861 BT_ERR("Error = %s", err->message);
862 g_dbus_error_strip_remote_error(err);
863 ret = _bt_get_error_value_from_message(err->message);
869 g_variant_unref(reply);
870 return BLUETOOTH_ERROR_NONE;
873 BT_EXPORT_API int bluetooth_hf_audio_disconnect(void)
875 GVariant *reply = NULL;
877 int ret = BLUETOOTH_ERROR_INTERNAL;
879 BT_CHECK_ENABLED(return);
881 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
882 "ScoDisconnect", &err, NULL);
884 BT_ERR("Error returned in method call\n");
886 BT_ERR("Error = %s", err->message);
887 g_dbus_error_strip_remote_error(err);
888 ret = _bt_get_error_value_from_message(err->message);
894 g_variant_unref(reply);
895 return BLUETOOTH_ERROR_NONE;
898 BT_EXPORT_API int bluetooth_hf_set_speaker_gain(unsigned int speaker_gain)
900 GVariant *reply = NULL;
902 GVariant *param = NULL;
903 int ret = BLUETOOTH_ERROR_INTERNAL;
905 BT_CHECK_ENABLED(return);
907 param = g_variant_new("(u)", speaker_gain);
908 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
909 "SpeakerGain", &err, param);
911 BT_ERR("Error returned in method call\n");
913 BT_ERR("Error = %s", err->message);
914 g_dbus_error_strip_remote_error(err);
915 ret = _bt_get_error_value_from_message(err->message);
921 g_variant_unref(reply);
922 return BLUETOOTH_ERROR_NONE;
925 BT_EXPORT_API int bluetooth_hf_send_dtmf(char *dtmf)
927 GVariant *reply = NULL;
929 GVariant *param = NULL;
930 int ret = BLUETOOTH_ERROR_INTERNAL;
932 BT_CHECK_ENABLED(return);
934 param = g_variant_new("(s)", dtmf);
935 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
936 "SendDtmf", &err, param);
938 BT_ERR("Error returned in method call\n");
940 BT_ERR("Error = %s", err->message);
941 g_dbus_error_strip_remote_error(err);
942 ret = _bt_get_error_value_from_message(err->message);
948 g_variant_unref(reply);
949 return BLUETOOTH_ERROR_NONE;
952 BT_EXPORT_API int bluetooth_hf_send_xsat_cmd(int app_id, char *xsat_cmd)
954 GVariant *reply = NULL;
956 GVariant *param = NULL;
957 char buffer[200] = {0,};
959 int ret = BLUETOOTH_ERROR_INTERNAL;
961 BT_CHECK_ENABLED(return);
963 strncpy(buffer, "AT+XSAT=\0", 200);
964 snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer),
966 strncat(buffer, xsat_cmd, (sizeof(buffer) - 1) - strlen(buffer));
967 BT_DBG("Xsat cmd received = %s", buffer);
969 param = g_variant_new("(s)", ptr);
971 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
972 "SendAtCmd", &err, param);
974 BT_ERR("Error returned in method call\n");
976 BT_ERR("Error = %s", err->message);
977 g_dbus_error_strip_remote_error(err);
978 ret = _bt_get_error_value_from_message(err->message);
984 g_variant_unref(reply);
985 return BLUETOOTH_ERROR_NONE;
988 BT_EXPORT_API int bluetooth_hf_release_and_accept(void)
990 GVariant *reply = NULL;
992 int ret = BLUETOOTH_ERROR_INTERNAL;
994 BT_CHECK_ENABLED(return);
996 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
997 "ReleaseAndAccept", &err, NULL);
999 BT_ERR("Error returned in method call\n");
1001 BT_ERR("Error = %s", err->message);
1002 g_dbus_error_strip_remote_error(err);
1003 ret = _bt_get_error_value_from_message(err->message);
1004 g_clear_error(&err);
1009 g_variant_unref(reply);
1010 return BLUETOOTH_ERROR_NONE;
1013 BT_EXPORT_API int bluetooth_hf_swap_call(void)
1015 GVariant *reply = NULL;
1017 int ret = BLUETOOTH_ERROR_INTERNAL;
1019 BT_CHECK_ENABLED(return);
1021 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1022 "CallSwap", &err, NULL);
1024 BT_ERR("Error returned in method call\n");
1026 BT_ERR("Error = %s", err->message);
1027 g_dbus_error_strip_remote_error(err);
1028 ret = _bt_get_error_value_from_message(err->message);
1029 g_clear_error(&err);
1034 g_variant_unref(reply);
1035 return BLUETOOTH_ERROR_NONE;
1038 BT_EXPORT_API int bluetooth_hf_release_all_call(void)
1040 GVariant *reply = NULL;
1042 int ret = BLUETOOTH_ERROR_INTERNAL;
1044 BT_CHECK_ENABLED(return);
1046 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1047 "ReleaseAllCall", &err, NULL);
1049 BT_ERR("Error returned in method call\n");
1051 BT_ERR("Error = %s", err->message);
1052 g_dbus_error_strip_remote_error(err);
1053 ret = _bt_get_error_value_from_message(err->message);
1054 g_clear_error(&err);
1059 g_variant_unref(reply);
1060 return BLUETOOTH_ERROR_NONE;
1063 BT_EXPORT_API int bluetooth_hf_join_call(void)
1065 GVariant *reply = NULL;
1067 int ret = BLUETOOTH_ERROR_INTERNAL;
1069 BT_CHECK_ENABLED(return);
1071 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1072 "JoinCall", &err, NULL);
1074 BT_ERR("Error returned in method call\n");
1076 BT_ERR("Error = %s", err->message);
1077 g_dbus_error_strip_remote_error(err);
1078 ret = _bt_get_error_value_from_message(err->message);
1079 g_clear_error(&err);
1084 g_variant_unref(reply);
1085 return BLUETOOTH_ERROR_NONE;
1088 BT_EXPORT_API int bluetooth_hf_get_call_list(void *call_list,
1089 bt_hf_call_status_info_t **call_status)
1092 GList *list = call_list;
1094 bt_hf_call_status_info_t * call_info;
1096 BT_CHECK_ENABLED(return);
1097 retv_if(list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1098 retv_if(call_status == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1100 call_count = g_list_length(list);
1102 BT_DBG(" call_count = [%d]", call_count);
1104 for (i = 0; i < call_count; i++) {
1105 call_info = g_list_nth_data(list, i);
1106 BT_DBG(" direction = [%d]", call_info->direction);
1107 BT_DBG(" status = [%d]", call_info->status);
1108 BT_DBG(" mpart = [%d]", call_info->mpart);
1109 BT_DBG(" number = [%s]", call_info->number);
1110 BT_DBG(" idx = [%d]", call_info->idx);
1111 call_status[i] = call_info;
1114 return BLUETOOTH_ERROR_NONE;
1117 BT_EXPORT_API int bluetooth_hf_free_call_list(bt_hf_call_list_s *call_list)
1119 bt_hf_call_list_s *handle;
1120 bt_hf_call_status_info_t *call_status;
1122 retv_if(call_list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1124 handle = (bt_hf_call_list_s *)call_list;
1126 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(
1128 if (call_status == NULL)
1130 handle->list = g_list_remove(handle->list, call_status);
1131 g_free(call_status->number);
1132 g_free(call_status);
1135 return BLUETOOTH_ERROR_NONE;
1138 BT_EXPORT_API int bluetooth_hf_request_call_list(
1139 bt_hf_call_list_s **call_list)
1141 GVariant *reply = NULL;
1144 BT_CHECK_ENABLED(return);
1146 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1147 "RequestCallList", &err, NULL);
1149 BT_ERR("dbus Error or call list is null\n");
1151 BT_ERR("Error = %s", err->message);
1152 g_clear_error(&err);
1155 return BLUETOOTH_ERROR_INTERNAL;
1157 __bt_hf_agent_read_call_list(reply, call_list);
1159 g_variant_unref(reply);
1160 return BLUETOOTH_ERROR_NONE;
1163 BT_EXPORT_API int bluetooth_hf_request_call_list_async(void)
1165 GVariant *reply = NULL;
1167 int ret = BLUETOOTH_ERROR_INTERNAL;
1169 BT_CHECK_ENABLED(return);
1171 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1172 "RequestCallListAsync", &err, NULL);
1174 BT_ERR("Error returned in method call\n");
1176 BT_ERR("Error = %s", err->message);
1177 if (strstr(err->message, "No data"))
1178 ret = BLUETOOTH_ERROR_NO_DATA;
1179 else if (strstr(err->message, "NotConnected"))
1180 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
1181 g_clear_error(&err);
1186 g_variant_unref(reply);
1187 return BLUETOOTH_ERROR_NONE;
1190 BT_EXPORT_API int bluetooth_hf_get_codec(unsigned int *codec_id)
1192 GVariant *reply = NULL;
1194 int32_t current_codec;
1196 BT_CHECK_ENABLED(return);
1198 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1199 "GetCurrentCodec", &err, NULL);
1201 BT_ERR("Error returned in method call\n");
1203 BT_ERR("Error = %s", err->message);
1204 g_clear_error(&err);
1206 return BLUETOOTH_ERROR_INTERNAL;
1209 g_variant_get(reply, "(i)", ¤t_codec);
1210 *codec_id = current_codec;
1211 BT_DBG(" Codec ID is : %d", *codec_id);
1213 g_variant_unref(reply);
1214 return BLUETOOTH_ERROR_NONE;
1217 BT_EXPORT_API int bluetooth_hf_get_audio_connected(unsigned int *audio_connected)
1219 GVariant *reply = NULL;
1221 int32_t sco_audio_connected_from_bt_agent;
1223 BT_CHECK_ENABLED(return);
1225 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1226 "GetAudioConnected", &err, NULL);
1228 BT_ERR("Error returned in method call\n");
1230 BT_ERR("Error = %s", err->message);
1231 g_clear_error(&err);
1233 return BLUETOOTH_ERROR_INTERNAL;
1236 g_variant_get(reply, "(i)", &sco_audio_connected_from_bt_agent);
1237 *audio_connected = sco_audio_connected_from_bt_agent;
1239 if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED)
1240 BT_DBG("SCO Audio is Connected");
1242 BT_DBG("SCO Audio is Disconnected");
1244 g_variant_unref(reply);
1245 return BLUETOOTH_ERROR_NONE;
1248 BT_EXPORT_API int bluetooth_hf_is_connected(gboolean *hf_connected)
1250 GVariant *reply = NULL;
1252 gboolean hf_connected_from_bt_agent;
1254 BT_CHECK_ENABLED(return);
1256 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1257 "IsHfConnected", &err, NULL);
1259 BT_ERR("Error returned in method call\n");
1261 BT_ERR("Error = %s", err->message);
1262 g_clear_error(&err);
1264 return BLUETOOTH_ERROR_INTERNAL;
1267 g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
1268 *hf_connected = hf_connected_from_bt_agent;
1270 BT_DBG("%s", *hf_connected ? "Connected" : "Disconnected");
1272 g_variant_unref(reply);
1273 return BLUETOOTH_ERROR_NONE;
1276 BT_EXPORT_API int bluetooth_hf_is_ibr_supported(gboolean *ibr_supported)
1278 GVariant *reply = NULL;
1280 gboolean is_supported;
1281 int ret = BLUETOOTH_ERROR_NONE;
1283 BT_CHECK_ENABLED(return);
1285 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1286 "IsInbandRingtoneSupported", &err, NULL);
1288 BT_ERR("Error returned in method call");
1290 g_dbus_error_strip_remote_error(err);
1291 ret = __bluetooth_hf_get_error(err->message);
1295 return BLUETOOTH_ERROR_INTERNAL;
1298 g_variant_get(reply, "(b)", &is_supported);
1299 *ibr_supported = is_supported;
1301 BT_DBG("%s", *ibr_supported ? "Supported" : "Not Supported");
1303 g_variant_unref(reply);