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 if (service_function == BT_AV_CONNECT)
132 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
133 in_param1, in_param2, in_param3, in_param4,
134 user_info->cb, user_info->user_data);
135 else if (service_function == BT_AG_CONNECT)
136 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
137 in_param1, in_param2, in_param3, in_param4,
138 user_info->cb, user_info->user_data);
139 else /* default case - with or without DPM enabled */
140 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_CONNECT,
141 in_param1, in_param2, in_param3, in_param4,
142 user_info->cb, user_info->user_data);
144 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
149 BT_EXPORT_API int bluetooth_audio_disconnect(bluetooth_device_address_t *remote_address)
152 bt_user_info_t *user_info;
154 BT_CHECK_PARAMETER(remote_address, return);
155 BT_CHECK_ENABLED(return);
157 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AUDIO_DISCONNECT)
158 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
159 BT_ERR("Don't have a privilege to use this API");
160 return BLUETOOTH_ERROR_PERMISSION_DEINED;
163 user_info = _bt_get_user_data(BT_AUDIO);
164 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
167 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
169 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
171 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_DISCONNECT,
172 in_param1, in_param2, in_param3, in_param4,
173 user_info->cb, user_info->user_data);
175 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
180 BT_EXPORT_API int bluetooth_ag_connect(bluetooth_device_address_t *remote_address)
183 bt_user_info_t *user_info;
185 BT_CHECK_PARAMETER(remote_address, return);
186 BT_CHECK_ENABLED(return);
188 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_CONNECT)
189 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
190 BT_ERR("Don't have a privilege to use this API");
191 return BLUETOOTH_ERROR_PERMISSION_DEINED;
194 #ifdef TIZEN_FEATURE_BT_DPM
195 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
196 BT_ERR("Blacklist device");
197 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
200 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
201 BT_ERR("Not allow to use HSP profile");
202 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
205 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
206 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
207 bluetooth_device_class_t dev_class;
209 _bt_convert_addr_type_to_string(address, remote_address->addr);
210 _bt_get_cod_by_address(address, &dev_class);
212 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
213 BT_ERR("Reject a authorization due to MDM Policy");
214 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
219 user_info = _bt_get_user_data(BT_AUDIO);
220 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
223 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
225 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
227 BT_INFO_C("### Connect AG");
228 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
229 in_param1, in_param2, in_param3, in_param4,
230 user_info->cb, user_info->user_data);
232 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
237 BT_EXPORT_API int bluetooth_ag_disconnect(bluetooth_device_address_t *remote_address)
240 bt_user_info_t *user_info;
242 BT_CHECK_PARAMETER(remote_address, return);
243 BT_CHECK_ENABLED(return);
245 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AG_DISCONNECT)
246 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
247 BT_ERR("Don't have a privilege to use this API");
248 return BLUETOOTH_ERROR_PERMISSION_DEINED;
251 user_info = _bt_get_user_data(BT_AUDIO);
252 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
255 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
257 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
259 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_DISCONNECT,
260 in_param1, in_param2, in_param3, in_param4,
261 user_info->cb, user_info->user_data);
263 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
268 BT_EXPORT_API int bluetooth_av_connect(bluetooth_device_address_t *remote_address)
271 bt_user_info_t *user_info;
273 BT_CHECK_PARAMETER(remote_address, return);
274 BT_CHECK_ENABLED(return);
276 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_CONNECT)
277 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
278 BT_ERR("Don't have a privilege to use this API");
279 return BLUETOOTH_ERROR_PERMISSION_DEINED;
282 #ifdef TIZEN_FEATURE_BT_DPM
283 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
284 BT_ERR("Blacklist device");
285 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
288 if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
289 BT_ERR("Not allow to use A2DP profile");
290 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
293 if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
294 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
295 bluetooth_device_class_t dev_class;
297 _bt_convert_addr_type_to_string(address, remote_address->addr);
298 _bt_get_cod_by_address(address, &dev_class);
300 if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
301 BT_ERR("Reject a authorization due to MDM Policy");
302 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
307 user_info = _bt_get_user_data(BT_AUDIO);
308 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
311 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
313 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
315 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
316 in_param1, in_param2, in_param3, in_param4,
317 user_info->cb, user_info->user_data);
319 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
324 BT_EXPORT_API int bluetooth_av_source_connect(bluetooth_device_address_t *remote_address)
327 bt_user_info_t *user_info;
329 BT_CHECK_PARAMETER(remote_address, return);
330 BT_CHECK_ENABLED(return);
332 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_CONNECT)
333 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
334 BT_ERR("Don't have a privilege to use this API");
335 return BLUETOOTH_ERROR_PERMISSION_DEINED;
338 #ifdef TIZEN_FEATURE_BT_DPM
339 if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
340 BT_ERR("Blacklist device");
341 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
344 if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
345 BT_ERR("Not allow to use A2DP profile");
346 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
350 user_info = _bt_get_user_data(BT_AUDIO);
351 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
354 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
356 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
358 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_CONNECT,
359 in_param1, in_param2, in_param3, in_param4,
360 user_info->cb, user_info->user_data);
362 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
367 BT_EXPORT_API int bluetooth_av_disconnect(bluetooth_device_address_t *remote_address)
370 bt_user_info_t *user_info;
372 BT_CHECK_PARAMETER(remote_address, return);
373 BT_CHECK_ENABLED(return);
375 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_DISCONNECT)
376 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
377 BT_ERR("Don't have a privilege to use this API");
378 return BLUETOOTH_ERROR_PERMISSION_DEINED;
381 user_info = _bt_get_user_data(BT_AUDIO);
382 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
385 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
387 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
389 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_DISCONNECT,
390 in_param1, in_param2, in_param3, in_param4,
391 user_info->cb, user_info->user_data);
393 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
398 BT_EXPORT_API int bluetooth_av_source_disconnect(bluetooth_device_address_t *remote_address)
401 bt_user_info_t *user_info;
403 BT_CHECK_PARAMETER(remote_address, return);
404 BT_CHECK_ENABLED(return);
406 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_DISCONNECT)
407 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
408 BT_ERR("Don't have a privilege to use this API");
409 return BLUETOOTH_ERROR_PERMISSION_DEINED;
412 user_info = _bt_get_user_data(BT_AUDIO);
413 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
416 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
418 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
420 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_DISCONNECT,
421 in_param1, in_param2, in_param3, in_param4,
422 user_info->cb, user_info->user_data);
424 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
429 BT_EXPORT_API int bluetooth_audio_select_role(bluetooth_audio_role_t role)
433 BT_CHECK_ENABLED(return);
436 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
438 g_array_append_vals(in_param1, &role, sizeof(bluetooth_audio_role_t));
440 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_SELECT_ROLE,
441 in_param1, in_param2, in_param3, in_param4, &out_param);
443 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
447 BT_EXPORT_API int bluetooth_ag_get_headset_volume(unsigned int *speaker_gain)
451 BT_CHECK_PARAMETER(speaker_gain, return);
452 BT_CHECK_ENABLED(return);
455 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
457 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SPEAKER_GAIN,
458 in_param1, in_param2, in_param3, in_param4, &out_param);
460 if (result == BLUETOOTH_ERROR_NONE) {
461 *speaker_gain = g_array_index(out_param,
465 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
470 BT_EXPORT_API int bluetooth_ag_set_speaker_gain(unsigned int speaker_gain)
474 BT_CHECK_ENABLED(return);
476 #ifdef TIZEN_FEATURE_BT_DPM
477 if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
478 BT_ERR("Not allow to use HSP profile");
479 return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
484 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
486 g_array_append_vals(in_param1, &speaker_gain, sizeof(unsigned int));
488 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SPEAKER_GAIN,
489 in_param1, in_param2, in_param3, in_param4, &out_param);
491 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
496 #define BT_HF_SERVICE_NAME "org.bluez.hf_agent"
497 #define BT_HF_OBJECT_PATH "/org/bluez/handsfree_agent"
498 #define BT_HF_INTERFACE "org.tizen.HfApp"
501 static GVariant* __bt_hf_agent_dbus_send(const char *path, const char *interface,
502 const char *method, GError **err, GVariant *parameters)
504 GVariant *reply = NULL;
505 GDBusProxy *proxy = NULL;
506 GDBusConnection *conn = NULL;
508 conn = _bt_gdbus_get_system_gconn();
509 retv_if(conn == NULL, NULL);
511 proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
512 NULL, BT_HF_SERVICE_NAME, path, interface, NULL, err);
514 BT_ERR("Unable to allocate new proxy");
518 reply = g_dbus_proxy_call_sync(proxy, method, parameters,
519 G_DBUS_CALL_FLAGS_NONE, -1, NULL, err);
521 g_object_unref(proxy);
525 static int __bt_hf_agent_read_call_list(GVariant *reply,
526 bt_hf_call_list_s **call_list) {
529 GVariant *var_temp = NULL;
532 int dir, status, mpart, idx;
536 g_variant_get(reply, "(i@a(siiii))", &call_count, &var_temp);
538 if (call_count <= 0) {
540 return BLUETOOTH_ERROR_NOT_FOUND;
542 BT_DBG("Call count = %d", call_count);
544 *call_list = g_malloc0(sizeof(bt_hf_call_list_s));
545 (*call_list)->count = call_count;
547 g_variant_iter_init(&iter, var_temp);
548 while (g_variant_iter_loop(&iter, "(siiii)", &num, &dir, &status, &mpart, &idx)) {
549 bt_hf_call_status_info_t *call_info;
551 call_info = g_malloc0(sizeof(bt_hf_call_status_info_t));
552 call_info->number = g_strdup(num);
553 call_info->direction = dir;
554 call_info->status = status;
555 call_info->mpart = mpart;
556 call_info->idx = idx;
558 (*call_list)->list = g_list_append((*call_list)->list,
559 (gpointer)call_info);
562 return BLUETOOTH_ERROR_NONE;
565 static int __bluetooth_hf_get_error(const char *error_message)
567 if (error_message == NULL) {
568 BT_ERR("Error message NULL");
569 return BLUETOOTH_ERROR_INTERNAL;
572 BT_ERR("Error message = %s", error_message);
574 if (g_strcmp0(error_message, "NotConnected") == 0)
575 return BLUETOOTH_ERROR_NOT_CONNECTED;
577 return BLUETOOTH_ERROR_INTERNAL;
580 BT_EXPORT_API int bluetooth_hf_init(bt_hf_func_ptr cb, void *user_data)
585 BT_ERR("callback is NULL");
586 return BLUETOOTH_ERROR_INVALID_PARAM;
589 ret = _bt_init_event_handler();
591 if (ret != BLUETOOTH_ERROR_NONE &&
592 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
593 BT_ERR("Fail to init the event handler");
597 _bt_set_user_data(BT_HF, (void *)cb, user_data);
599 /* Register All events */
600 ret = _bt_register_event(BT_HF_AGENT_EVENT, (void *)cb, user_data);
601 if (ret != BLUETOOTH_ERROR_NONE &&
602 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
603 _bt_deinit_event_handler();
607 return BLUETOOTH_ERROR_NONE;
610 BT_EXPORT_API int bluetooth_hf_deinit(void)
614 ret = _bt_unregister_event(BT_HF_AGENT_EVENT);
615 if (ret != BLUETOOTH_ERROR_NONE)
616 BT_ERR("_bt_unregister_event failed");
618 _bt_set_user_data(BT_HF, NULL, NULL);
620 return BLUETOOTH_ERROR_NONE;
623 BT_EXPORT_API int bluetooth_hf_connect(bluetooth_device_address_t *remote_address)
626 bt_user_info_t *user_info;
628 BT_CHECK_ENABLED(return);
629 BT_CHECK_PARAMETER(remote_address, return);
631 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_CONNECT)
632 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
633 BT_ERR("Don't have a privilege to use this API");
634 return BLUETOOTH_ERROR_PERMISSION_DEINED;
637 user_info = _bt_get_user_data(BT_HF);
638 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
641 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
643 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
645 BT_INFO_C("### Connect HF");
646 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_CONNECT,
647 in_param1, in_param2, in_param3, in_param4,
648 user_info->cb, user_info->user_data);
650 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
655 BT_EXPORT_API int bluetooth_hf_disconnect(bluetooth_device_address_t *remote_address)
658 bt_user_info_t *user_info;
660 BT_CHECK_PARAMETER(remote_address, return);
661 BT_CHECK_ENABLED(return);
663 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HF_DISCONNECT)
664 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
665 BT_ERR("Don't have a privilege to use this API");
666 return BLUETOOTH_ERROR_PERMISSION_DEINED;
669 user_info = _bt_get_user_data(BT_HF);
670 retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
673 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
675 g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
677 result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_DISCONNECT,
678 in_param1, in_param2, in_param3, in_param4,
679 user_info->cb, user_info->user_data);
681 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
686 BT_EXPORT_API int bluetooth_hf_answer_call()
688 GVariant *reply = NULL;
690 int ret = BLUETOOTH_ERROR_INTERNAL;
692 BT_CHECK_ENABLED(return);
694 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
695 "AnswerCall", &err, NULL);
697 BT_ERR("Error returned in method call\n");
699 BT_ERR("Error = %s", err->message);
700 g_dbus_error_strip_remote_error(err);
701 ret = _bt_get_error_value_from_message(err->message);
707 g_variant_unref(reply);
708 return BLUETOOTH_ERROR_NONE;
712 BT_EXPORT_API int bluetooth_hf_terminate_call()
714 GVariant *reply = NULL;
716 int ret = BLUETOOTH_ERROR_INTERNAL;
718 BT_CHECK_ENABLED(return);
720 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
721 "TerminateCall", &err, NULL);
723 BT_ERR("Error returned in method call\n");
725 BT_ERR("Error = %s", err->message);
726 g_dbus_error_strip_remote_error(err);
727 ret = _bt_get_error_value_from_message(err->message);
733 g_variant_unref(reply);
734 return BLUETOOTH_ERROR_NONE;
737 BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
739 GVariant *reply = NULL;
741 GVariant *param = NULL;
742 int ret = BLUETOOTH_ERROR_INTERNAL;
744 BT_CHECK_ENABLED(return);
749 param = g_variant_new("(s)", number);
750 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
751 "InitiateCall", &err, param);
753 BT_ERR("Error returned in method call");
755 BT_ERR("Error = %s", err->message);
756 g_dbus_error_strip_remote_error(err);
757 ret = _bt_get_error_value_from_message(err->message);
763 g_variant_unref(reply);
764 return BLUETOOTH_ERROR_NONE;
767 BT_EXPORT_API int bluetooth_hf_voice_recognition(unsigned int status)
769 GVariant *reply = NULL;
771 GVariant *param = NULL;
772 int ret = BLUETOOTH_ERROR_INTERNAL;
774 BT_CHECK_ENABLED(return);
776 param = g_variant_new("(i)", status);
777 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
778 "VoiceRecognition", &err, param);
780 BT_ERR("Error returned in method call\n");
782 BT_ERR("Error = %s", err->message);
783 g_dbus_error_strip_remote_error(err);
784 ret = _bt_get_error_value_from_message(err->message);
790 g_variant_unref(reply);
791 return BLUETOOTH_ERROR_NONE;
794 BT_EXPORT_API int bluetooth_hf_audio_disconnect(void)
796 GVariant *reply = NULL;
798 int ret = BLUETOOTH_ERROR_INTERNAL;
800 BT_CHECK_ENABLED(return);
802 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
803 "ScoDisconnect", &err, NULL);
805 BT_ERR("Error returned in method call\n");
807 BT_ERR("Error = %s", err->message);
808 g_dbus_error_strip_remote_error(err);
809 ret = _bt_get_error_value_from_message(err->message);
815 g_variant_unref(reply);
816 return BLUETOOTH_ERROR_NONE;
819 BT_EXPORT_API int bluetooth_hf_set_speaker_gain(unsigned int speaker_gain)
821 GVariant *reply = NULL;
823 GVariant *param = NULL;
824 int ret = BLUETOOTH_ERROR_INTERNAL;
826 BT_CHECK_ENABLED(return);
828 param = g_variant_new("(u)", speaker_gain);
829 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
830 "SpeakerGain", &err, param);
832 BT_ERR("Error returned in method call\n");
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_send_dtmf(char *dtmf)
848 GVariant *reply = NULL;
850 GVariant *param = NULL;
851 int ret = BLUETOOTH_ERROR_INTERNAL;
853 BT_CHECK_ENABLED(return);
855 param = g_variant_new("(s)", dtmf);
856 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
857 "SendDtmf", &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_send_xsat_cmd(int app_id, char *xsat_cmd)
875 GVariant *reply = NULL;
877 GVariant *param = NULL;
878 char buffer[200] = {0,};
880 int ret = BLUETOOTH_ERROR_INTERNAL;
882 BT_CHECK_ENABLED(return);
884 strncpy(buffer, "AT+XSAT=\0", 200);
885 snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer),
887 strncat(buffer, xsat_cmd, (sizeof(buffer) - 1) - strlen(buffer));
888 BT_DBG("Xsat cmd received = %s", buffer);
890 param = g_variant_new("(s)", ptr);
892 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
893 "SendAtCmd", &err, param);
895 BT_ERR("Error returned in method call\n");
897 BT_ERR("Error = %s", err->message);
898 g_dbus_error_strip_remote_error(err);
899 ret = _bt_get_error_value_from_message(err->message);
905 g_variant_unref(reply);
906 return BLUETOOTH_ERROR_NONE;
909 BT_EXPORT_API int bluetooth_hf_release_and_accept(void)
911 GVariant *reply = NULL;
913 int ret = BLUETOOTH_ERROR_INTERNAL;
915 BT_CHECK_ENABLED(return);
917 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
918 "ReleaseAndAccept", &err, NULL);
920 BT_ERR("Error returned in method call\n");
922 BT_ERR("Error = %s", err->message);
923 g_dbus_error_strip_remote_error(err);
924 ret = _bt_get_error_value_from_message(err->message);
930 g_variant_unref(reply);
931 return BLUETOOTH_ERROR_NONE;
934 BT_EXPORT_API int bluetooth_hf_swap_call(void)
936 GVariant *reply = NULL;
938 int ret = BLUETOOTH_ERROR_INTERNAL;
940 BT_CHECK_ENABLED(return);
942 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
943 "CallSwap", &err, NULL);
945 BT_ERR("Error returned in method call\n");
947 BT_ERR("Error = %s", err->message);
948 g_dbus_error_strip_remote_error(err);
949 ret = _bt_get_error_value_from_message(err->message);
955 g_variant_unref(reply);
956 return BLUETOOTH_ERROR_NONE;
959 BT_EXPORT_API int bluetooth_hf_release_all_call(void)
961 GVariant *reply = NULL;
963 int ret = BLUETOOTH_ERROR_INTERNAL;
965 BT_CHECK_ENABLED(return);
967 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
968 "ReleaseAllCall", &err, NULL);
970 BT_ERR("Error returned in method call\n");
972 BT_ERR("Error = %s", err->message);
973 g_dbus_error_strip_remote_error(err);
974 ret = _bt_get_error_value_from_message(err->message);
980 g_variant_unref(reply);
981 return BLUETOOTH_ERROR_NONE;
984 BT_EXPORT_API int bluetooth_hf_join_call(void)
986 GVariant *reply = NULL;
988 int ret = BLUETOOTH_ERROR_INTERNAL;
990 BT_CHECK_ENABLED(return);
992 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
993 "JoinCall", &err, NULL);
995 BT_ERR("Error returned in method call\n");
997 BT_ERR("Error = %s", err->message);
998 g_dbus_error_strip_remote_error(err);
999 ret = _bt_get_error_value_from_message(err->message);
1000 g_clear_error(&err);
1005 g_variant_unref(reply);
1006 return BLUETOOTH_ERROR_NONE;
1009 BT_EXPORT_API int bluetooth_hf_get_call_list(void *call_list,
1010 bt_hf_call_status_info_t **call_status)
1013 GList *list = call_list;
1015 bt_hf_call_status_info_t * call_info;
1017 BT_CHECK_ENABLED(return);
1018 retv_if(list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1019 retv_if(call_status == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1021 call_count = g_list_length(list);
1023 BT_DBG(" call_count = [%d]", call_count);
1025 for (i = 0; i < call_count; i++) {
1026 call_info = g_list_nth_data(list, i);
1027 BT_DBG(" direction = [%d]", call_info->direction);
1028 BT_DBG(" status = [%d]", call_info->status);
1029 BT_DBG(" mpart = [%d]", call_info->mpart);
1030 BT_DBG(" number = [%s]", call_info->number);
1031 BT_DBG(" idx = [%d]", call_info->idx);
1032 call_status[i] = call_info;
1035 return BLUETOOTH_ERROR_NONE;
1038 BT_EXPORT_API int bluetooth_hf_free_call_list(bt_hf_call_list_s *call_list)
1040 bt_hf_call_list_s *handle;
1041 bt_hf_call_status_info_t *call_status;
1043 retv_if(call_list == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1045 handle = (bt_hf_call_list_s *)call_list;
1047 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(
1049 if (call_status == NULL)
1051 handle->list = g_list_remove(handle->list, call_status);
1052 g_free(call_status->number);
1053 g_free(call_status);
1056 return BLUETOOTH_ERROR_NONE;
1059 BT_EXPORT_API int bluetooth_hf_request_call_list(
1060 bt_hf_call_list_s **call_list)
1062 GVariant *reply = NULL;
1065 BT_CHECK_ENABLED(return);
1067 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1068 "RequestCallList", &err, NULL);
1070 BT_ERR("dbus Error or call list is null\n");
1072 BT_ERR("Error = %s", err->message);
1073 g_clear_error(&err);
1076 return BLUETOOTH_ERROR_INTERNAL;
1078 __bt_hf_agent_read_call_list(reply, call_list);
1080 g_variant_unref(reply);
1081 return BLUETOOTH_ERROR_NONE;
1084 BT_EXPORT_API int bluetooth_hf_get_codec(unsigned int *codec_id)
1086 GVariant *reply = NULL;
1088 int32_t current_codec;
1090 BT_CHECK_ENABLED(return);
1092 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1093 "GetCurrentCodec", &err, NULL);
1095 BT_ERR("Error returned in method call\n");
1097 BT_ERR("Error = %s", err->message);
1098 g_clear_error(&err);
1100 return BLUETOOTH_ERROR_INTERNAL;
1103 g_variant_get(reply, "(i)", ¤t_codec);
1104 *codec_id = current_codec;
1105 BT_DBG(" Codec ID is : %d", *codec_id);
1107 g_variant_unref(reply);
1108 return BLUETOOTH_ERROR_NONE;
1111 BT_EXPORT_API int bluetooth_hf_get_audio_connected(unsigned int *audio_connected)
1113 GVariant *reply = NULL;
1115 int32_t sco_audio_connected_from_bt_agent;
1117 BT_CHECK_ENABLED(return);
1119 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1120 "GetAudioConnected", &err, NULL);
1122 BT_ERR("Error returned in method call\n");
1124 BT_ERR("Error = %s", err->message);
1125 g_clear_error(&err);
1127 return BLUETOOTH_ERROR_INTERNAL;
1130 g_variant_get(reply, "(i)", &sco_audio_connected_from_bt_agent);
1131 *audio_connected = sco_audio_connected_from_bt_agent;
1133 if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED)
1134 BT_DBG("SCO Audio is Connected");
1136 BT_DBG("SCO Audio is Disconnected");
1138 g_variant_unref(reply);
1139 return BLUETOOTH_ERROR_NONE;
1142 BT_EXPORT_API int bluetooth_hf_is_connected(gboolean *hf_connected)
1144 GVariant *reply = NULL;
1146 gboolean hf_connected_from_bt_agent;
1148 BT_CHECK_ENABLED(return);
1150 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1151 "IsHfConnected", &err, NULL);
1153 BT_ERR("Error returned in method call\n");
1155 BT_ERR("Error = %s", err->message);
1156 g_clear_error(&err);
1158 return BLUETOOTH_ERROR_INTERNAL;
1161 g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
1162 *hf_connected = hf_connected_from_bt_agent;
1164 BT_DBG("%s", *hf_connected ? "Connected" : "Disconnected");
1166 g_variant_unref(reply);
1167 return BLUETOOTH_ERROR_NONE;
1170 BT_EXPORT_API int bluetooth_hf_is_ibr_supported(gboolean *ibr_supported)
1172 GVariant *reply = NULL;
1174 gboolean is_supported;
1175 int ret = BLUETOOTH_ERROR_NONE;
1177 BT_CHECK_ENABLED(return);
1179 reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
1180 "IsInbandRingtoneSupported", &err, NULL);
1182 BT_ERR("Error returned in method call");
1184 g_dbus_error_strip_remote_error(err);
1185 ret = __bluetooth_hf_get_error(err->message);
1189 return BLUETOOTH_ERROR_INTERNAL;
1192 g_variant_get(reply, "(b)", &is_supported);
1193 *ibr_supported = is_supported;
1195 BT_DBG("%s", *ibr_supported ? "Supported" : "Not Supported");
1197 g_variant_unref(reply);