/*
- * Bluetooth-frwk
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Hocheol Seo <hocheol.seo@samsung.com>
- * Girishashok Joshi <girish.joshi@samsung.com>
- * Chanyeol Park <chanyeol.park@samsung.com>
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
+#ifdef TIZEN_FEATURE_BT_DPM
+#include "bt-dpm.h"
+#endif
BT_EXPORT_API int bluetooth_audio_init(bt_audio_func_ptr cb, void *user_data)
{
return ret;
}
+ ret = _bt_register_event(BT_A2DP_SOURCE_EVENT, (void *)cb, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE &&
+ ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
+ _bt_deinit_event_handler();
+ return ret;
+ }
+
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_audio_deinit(void)
{
_bt_unregister_event(BT_HEADSET_EVENT);
-
+ _bt_unregister_event(BT_A2DP_SOURCE_EVENT);
_bt_set_user_data(BT_AUDIO, NULL, NULL);
return BLUETOOTH_ERROR_NONE;
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
+#ifdef TIZEN_FEATURE_BT_DPM
+ if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
+ BT_ERR("Blacklist device");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+
+ if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED &&
+ _bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use HSP / A2DP profile");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ } else if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use HSP profile");
+ service_function = BT_AV_CONNECT;
+ } else if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use A2DP profile");
+ service_function = BT_AG_CONNECT;
+ }
+
+ if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ bluetooth_device_class_t dev_class;
+
+ _bt_convert_addr_type_to_string(address, remote_address->addr);
+ _bt_get_cod_by_address(address, &dev_class);
+
+ if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
+ BT_ERR("Reject a authorization due to MDM Policy");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+ }
+#endif
+
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
- result = _bt_send_request_async(BT_BLUEZ_SERVICE, service_function,
- in_param1, in_param2, in_param3, in_param4,
- user_info->cb, user_info->user_data);
+#ifdef TIZEN_FEATURE_BT_DPM
+ if (service_function == BT_AV_CONNECT)
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
+ in_param1, in_param2, in_param3, in_param4,
+ user_info->cb, user_info->user_data);
+ else if (service_function == BT_AG_CONNECT)
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
+ in_param1, in_param2, in_param3, in_param4,
+ user_info->cb, user_info->user_data);
+ else /* default case - with or without DPM enabled */
+#endif
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_CONNECT,
+ in_param1, in_param2, in_param3, in_param4,
+ user_info->cb, user_info->user_data);
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
+#ifdef TIZEN_FEATURE_BT_DPM
+ if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
+ BT_ERR("Blacklist device");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+
+ if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use HSP profile");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+
+ if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ bluetooth_device_class_t dev_class;
+
+ _bt_convert_addr_type_to_string(address, remote_address->addr);
+ _bt_get_cod_by_address(address, &dev_class);
+
+ if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
+ BT_ERR("Reject a authorization due to MDM Policy");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+ }
+#endif
+
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+ BT_INFO_C("### Connect AG");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_CONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+ BT_INFO_C("### Disconnect AG");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AG_DISCONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
+#ifdef TIZEN_FEATURE_BT_DPM
+ if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
+ BT_ERR("Blacklist device");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+
+ if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use A2DP profile");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+
+ if (_bt_check_dpm(BT_DPM_DESKTOP, NULL) == BT_DPM_RESTRICTED) {
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ bluetooth_device_class_t dev_class;
+
+ _bt_convert_addr_type_to_string(address, remote_address->addr);
+ _bt_get_cod_by_address(address, &dev_class);
+
+ if (dev_class.major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
+ BT_ERR("Reject a authorization due to MDM Policy");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+ }
+#endif
+
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+ BT_INFO_C("### Connect AV");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
return result;
}
+BT_EXPORT_API int bluetooth_av_source_connect(bluetooth_device_address_t *remote_address)
+{
+ int result;
+ bt_user_info_t *user_info;
+
+ BT_CHECK_PARAMETER(remote_address, return);
+ BT_CHECK_ENABLED(return);
+
+ if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_CONNECT)
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have a privilege to use this API");
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ }
+
+#ifdef TIZEN_FEATURE_BT_DPM
+ if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
+ BT_ERR("Blacklist device");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+
+ if (_bt_check_dpm(BT_DPM_A2DP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use A2DP profile");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+#endif
+
+ user_info = _bt_get_user_data(BT_AUDIO);
+ retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+
+ BT_INFO_C("### Connect AV Source");
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_CONNECT,
+ in_param1, in_param2, in_param3, in_param4,
+ user_info->cb, user_info->user_data);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
BT_EXPORT_API int bluetooth_av_disconnect(bluetooth_device_address_t *remote_address)
{
int result;
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+ BT_INFO_C("### Disconnect AV");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_DISCONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
return result;
}
+BT_EXPORT_API int bluetooth_av_source_disconnect(bluetooth_device_address_t *remote_address)
+{
+ int result;
+ bt_user_info_t *user_info;
+
+ BT_CHECK_PARAMETER(remote_address, return);
+ BT_CHECK_ENABLED(return);
+
+ if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_AV_SOURCE_DISCONNECT)
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have a privilege to use this API");
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ }
+
+ user_info = _bt_get_user_data(BT_AUDIO);
+ retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+
+ BT_INFO_C("### Disconnect AV Source");
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_SOURCE_DISCONNECT,
+ in_param1, in_param2, in_param3, in_param4,
+ user_info->cb, user_info->user_data);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_audio_select_role(bluetooth_audio_role_t role)
+{
+ int result;
+
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, &role, sizeof(bluetooth_audio_role_t));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_AUDIO_SELECT_ROLE,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ return result;
+}
+
BT_EXPORT_API int bluetooth_ag_get_headset_volume(unsigned int *speaker_gain)
{
int result;
BT_CHECK_ENABLED(return);
+#ifdef TIZEN_FEATURE_BT_DPM
+ if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use HSP profile");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+#endif
+
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
#define BT_HF_INTERFACE "org.tizen.HfApp"
-static DBusMessage* __bt_hf_agent_dbus_send(const char *path,
- const char *interface, const char *method, DBusError *err, int type, ...)
+static GVariant* __bt_hf_agent_dbus_send(const char *path, const char *interface,
+ const char *method, GError **err, GVariant *parameters)
{
- DBusMessage *msg;
- DBusMessage *reply;
- va_list args;
-
- msg = dbus_message_new_method_call(BT_HF_SERVICE_NAME,
- path, interface, method);
- if (!msg) {
- BT_ERR("Unable to allocate new D-Bus %s message \n", method);
- return NULL;
- }
+ GVariant *reply = NULL;
+ GDBusProxy *proxy = NULL;
+ GDBusConnection *conn = NULL;
- va_start(args, type);
+ conn = _bt_get_system_private_conn();
+ retv_if(conn == NULL, NULL);
- if (!dbus_message_append_args_valist(msg, type, args)) {
- dbus_message_unref(msg);
- va_end(args);
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+ NULL, BT_HF_SERVICE_NAME, path, interface, NULL, err);
+ if (proxy == NULL) {
+ BT_ERR("Unable to allocate new proxy");
return NULL;
}
- va_end(args);
-
- dbus_error_init(err);
-
- BT_DBG("DBus HF API call, method = %s", method);
-
- reply = dbus_connection_send_with_reply_and_block(_bt_get_system_conn(),
- msg, 4000, err);
- dbus_message_unref(msg);
+ reply = g_dbus_proxy_call_sync(proxy, method, parameters,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, err);
+ g_object_unref(proxy);
return reply;
}
-static int __bt_hf_agent_read_call_list(DBusMessage *reply,
+static int __bt_hf_agent_read_call_list(GVariant *reply,
bt_hf_call_list_s **call_list) {
- DBusMessageIter iter;
- DBusMessageIter iter_struct;
+ GVariantIter iter;
+ GVariant *var_temp = NULL;
int32_t call_count;
+ gchar *num = NULL;
+ int dir, status, mpart, idx;
BT_DBG("+");
- dbus_message_iter_init(reply, &iter);
- dbus_message_iter_get_basic(&iter, &call_count);
- if(call_count <= 0) {
+ g_variant_get(reply, "(i@a(siiii))", &call_count, &var_temp);
+
+ if (call_count <= 0) {
*call_list = NULL;
return BLUETOOTH_ERROR_NOT_FOUND;
}
*call_list = g_malloc0(sizeof(bt_hf_call_list_s));
(*call_list)->count = call_count;
- dbus_message_iter_next(&iter);
- dbus_message_iter_recurse(&iter, &iter_struct);
- while(dbus_message_iter_get_arg_type(&iter_struct) ==
- DBUS_TYPE_STRUCT) {
- gchar *number = NULL;
+ g_variant_iter_init(&iter, var_temp);
+ while (g_variant_iter_loop(&iter, "(siiii)", &num, &dir, &status, &mpart, &idx)) {
bt_hf_call_status_info_t *call_info;
- DBusMessageIter entry_iter;
call_info = g_malloc0(sizeof(bt_hf_call_status_info_t));
-
- dbus_message_iter_recurse(&iter_struct,&entry_iter);
-
- dbus_message_iter_get_basic(&entry_iter, &number);
- call_info->number = g_strdup(number);
- dbus_message_iter_next(&entry_iter);
- dbus_message_iter_get_basic(&entry_iter, &call_info->direction);
- dbus_message_iter_next(&entry_iter);
- dbus_message_iter_get_basic(&entry_iter, &call_info->status);
- dbus_message_iter_next(&entry_iter);
- dbus_message_iter_get_basic(&entry_iter, &call_info->mpart);
- dbus_message_iter_next(&entry_iter);
- dbus_message_iter_get_basic(&entry_iter, &call_info->idx);
+ call_info->number = g_strdup(num);
+ call_info->direction = dir;
+ call_info->status = status;
+ call_info->mpart = mpart;
+ call_info->idx = idx;
(*call_list)->list = g_list_append((*call_list)->list,
(gpointer)call_info);
- dbus_message_iter_next(&iter_struct);
}
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
+static int __bluetooth_hf_get_error(const char *error_message)
+{
+ if (error_message == NULL) {
+ BT_ERR("Error message NULL");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ BT_ERR("Error message = %s", error_message);
+
+ if (g_strcmp0(error_message, "NotConnected") == 0)
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ else
+ return BLUETOOTH_ERROR_INTERNAL;
+}
+
BT_EXPORT_API int bluetooth_hf_init(bt_hf_func_ptr cb, void *user_data)
{
int ret;
return BLUETOOTH_ERROR_INVALID_PARAM;
}
- ret = dbus_threads_init_default();
-
- if (ret)
- BT_ERR("dbus_thread_init_default Success");
- else
- BT_ERR("dbus_thread_init_default Fail");
-
ret = _bt_init_event_handler();
if (ret != BLUETOOTH_ERROR_NONE &&
int ret;
ret = _bt_unregister_event(BT_HF_AGENT_EVENT);
- if (ret != BLUETOOTH_ERROR_NONE )
+ if (ret != BLUETOOTH_ERROR_NONE)
BT_ERR("_bt_unregister_event failed");
_bt_set_user_data(BT_HF, NULL, NULL);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+ BT_INFO_C("### Connect HF");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_CONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
+ BT_INFO_C("### Disconnect HF");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_HF_DISCONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
BT_EXPORT_API int bluetooth_hf_answer_call()
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "AnswerCall", &err, DBUS_TYPE_INVALID);
+ "AnswerCall", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- if (strcmp(err.message, "Operation not supported") == 0)
- ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
- else if (strcmp(err.message, "Operation not allowed") == 0)
- ret = BLUETOOTH_ERROR_PERMISSION_DEINED;
- else
- ret = BLUETOOTH_ERROR_INTERNAL;
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_terminate_call()
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "TerminateCall", &err, DBUS_TYPE_INVALID);
+ "TerminateCall", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ GVariant *param = NULL;
int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
if (!number)
number = "";
+ param = g_variant_new("(s)", number);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "InitiateCall", &err, DBUS_TYPE_STRING, &number, DBUS_TYPE_INVALID);
+ "InitiateCall", &err, param);
if (!reply) {
BT_ERR("Error returned in method call");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- if (strcmp(err.message, "NotConnected") == 0)
- ret = BLUETOOTH_ERROR_NOT_CONNECTED;
- else if (strcmp(err.message, "Operation not allowed") == 0)
- ret = BLUETOOTH_ERROR_IN_PROGRESS;
- else
- ret = BLUETOOTH_ERROR_INTERNAL;
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_voice_recognition(unsigned int status)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ GVariant *param = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
+ param = g_variant_new("(i)", status);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "VoiceRecognition", &err, DBUS_TYPE_INT32, &status, DBUS_TYPE_INVALID);
+ "VoiceRecognition", &err, param);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_audio_disconnect(void)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "ScoDisconnect", &err, DBUS_TYPE_INVALID);
+ "ScoDisconnect", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_set_speaker_gain(unsigned int speaker_gain)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ GVariant *param = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
+ param = g_variant_new("(u)", speaker_gain);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "SpeakerGain", &err, DBUS_TYPE_UINT32, &speaker_gain, DBUS_TYPE_INVALID);
+ "SpeakerGain", &err, param);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_send_dtmf(char *dtmf)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ GVariant *param = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
+ param = g_variant_new("(s)", dtmf);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "SendDtmf", &err, DBUS_TYPE_STRING, &dtmf, DBUS_TYPE_INVALID);
+ "SendDtmf", &err, param);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_send_xsat_cmd(int app_id, char *xsat_cmd)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ GVariant *param = NULL;
char buffer[200] = {0,};
char *ptr = buffer;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
- strcpy(buffer, "AT+XSAT=");
- snprintf(buffer + strlen(buffer), sizeof(buffer), "%d,", app_id);
+ strncpy(buffer, "AT+XSAT=\0", 200);
+ snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer),
+ "%d,", app_id);
strncat(buffer, xsat_cmd, (sizeof(buffer) - 1) - strlen(buffer));
BT_DBG("Xsat cmd received = %s", buffer);
+
+ param = g_variant_new("(s)", ptr);
+
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "SendAtCmd", &err, DBUS_TYPE_STRING,
- &ptr, DBUS_TYPE_INVALID);
+ "SendAtCmd", &err, param);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_release_and_accept(void)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "ReleaseAndAccept", &err, DBUS_TYPE_INVALID);
+ "ReleaseAndAccept", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_swap_call(void)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "CallSwap", &err, DBUS_TYPE_INVALID);
+ "CallSwap", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_release_all_call(void)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "ReleaseAllCall", &err, DBUS_TYPE_INVALID);
+ "ReleaseAllCall", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_join_call(void)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "JoinCall", &err, DBUS_TYPE_INVALID);
+ "JoinCall", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ ret = _bt_get_error_value_from_message(err->message);
+ g_clear_error(&err);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_request_call_list(
bt_hf_call_list_s **call_list)
{
- DBusMessage *reply;
- DBusError err;
+ GVariant *reply = NULL;
+ GError *err = NULL;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "RequestCallList", &err, DBUS_TYPE_INVALID);
+ "RequestCallList", &err, NULL);
if (!reply) {
BT_ERR("dbus Error or call list is null\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_clear_error(&err);
}
*call_list = NULL;
return BLUETOOTH_ERROR_INTERNAL;
}
__bt_hf_agent_read_call_list(reply, call_list);
- dbus_message_unref(reply);
+ g_variant_unref(reply);
+ return BLUETOOTH_ERROR_NONE;
+}
+
+BT_EXPORT_API int bluetooth_hf_request_call_list_async(void)
+{
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ int ret = BLUETOOTH_ERROR_INTERNAL;
+
+ BT_CHECK_ENABLED(return);
+
+ reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
+ "RequestCallListAsync", &err, NULL);
+ if (!reply) {
+ BT_ERR("Error returned in method call\n");
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ if (strstr(err->message, "No data"))
+ ret = BLUETOOTH_ERROR_NO_DATA;
+ else if (strstr(err->message, "NotConnected"))
+ ret = BLUETOOTH_ERROR_NOT_CONNECTED;
+ g_clear_error(&err);
+ }
+ return ret;
+ }
+
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_get_codec(unsigned int *codec_id)
{
- DBusMessage *reply;
- DBusError err;
- DBusMessageIter iter;
+ GVariant *reply = NULL;
+ GError *err = NULL;
int32_t current_codec;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "GetCurrentCodec", &err, DBUS_TYPE_INVALID);
+ "GetCurrentCodec", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- dbus_message_iter_init(reply, &iter);
- dbus_message_iter_get_basic(&iter, ¤t_codec);
+
+ g_variant_get(reply, "(i)", ¤t_codec);
*codec_id = current_codec;
BT_DBG(" Codec ID is : %d", *codec_id);
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
BT_EXPORT_API int bluetooth_hf_get_audio_connected(unsigned int *audio_connected)
{
- DBusMessage *reply;
- DBusError err;
- DBusMessageIter iter;
+ GVariant *reply = NULL;
+ GError *err = NULL;
int32_t sco_audio_connected_from_bt_agent;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "GetAudioConnected", &err, DBUS_TYPE_INVALID);
+ "GetAudioConnected", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- dbus_message_iter_init(reply, &iter);
- dbus_message_iter_get_basic(&iter, &sco_audio_connected_from_bt_agent);
+
+ g_variant_get(reply, "(i)", &sco_audio_connected_from_bt_agent);
*audio_connected = sco_audio_connected_from_bt_agent;
- if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED) {
+ if (*audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED)
BT_DBG("SCO Audio is Connected");
- } else {
+ else
BT_DBG("SCO Audio is Disconnected");
- }
-
- dbus_message_unref(reply);
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
-BT_EXPORT_API int bluetooth_hf_is_hf_connected(gboolean *hf_connected)
+BT_EXPORT_API int bluetooth_hf_is_connected(gboolean *hf_connected)
{
- DBusMessage *reply;
- DBusError err;
- DBusMessageIter iter;
+ GVariant *reply = NULL;
+ GError *err = NULL;
gboolean hf_connected_from_bt_agent;
BT_CHECK_ENABLED(return);
reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
- "IsHfConnected", &err, DBUS_TYPE_INVALID);
+ "IsHfConnected", &err, NULL);
if (!reply) {
BT_ERR("Error returned in method call\n");
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error = %s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- dbus_message_iter_init(reply, &iter);
- dbus_message_iter_get_basic(&iter, &hf_connected_from_bt_agent);
- *hf_connected = hf_connected_from_bt_agent;
- BT_DBG("%s", *hf_connected ? "Connected":"Disconnected");
+ g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
+ *hf_connected = hf_connected_from_bt_agent;
- dbus_message_unref(reply);
+ BT_DBG("%s", *hf_connected ? "Connected" : "Disconnected");
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
+BT_EXPORT_API int bluetooth_hf_is_ibr_supported(gboolean *ibr_supported)
+{
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ gboolean is_supported;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_ENABLED(return);
+
+ reply = __bt_hf_agent_dbus_send(BT_HF_OBJECT_PATH, BT_HF_INTERFACE,
+ "IsInbandRingtoneSupported", &err, NULL);
+ if (!reply) {
+ BT_ERR("Error returned in method call");
+ if (err) {
+ g_dbus_error_strip_remote_error(err);
+ ret = __bluetooth_hf_get_error(err->message);
+ g_error_free(err);
+ return ret;
+ }
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_variant_get(reply, "(b)", &is_supported);
+ *ibr_supported = is_supported;
+
+ BT_DBG("%s", *ibr_supported ? "Supported" : "Not Supported");
+
+ g_variant_unref(reply);
+ return ret;
+}
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff