#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_gdbus_get_system_gconn();
+ 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_NONE,
+ 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);
+ g_variant_get(reply, "(i@a(siiii))", &call_count, &var_temp);
+
if(call_count <= 0) {
*call_list = NULL;
return BLUETOOTH_ERROR_NOT_FOUND;
retv_if(*call_list == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
(*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));
/* Fix : NULL_RETURNS */
retv_if(call_info == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
- 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;
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 &&
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)
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ if (strcmp(err->message, "Operation not supported") == 0)
ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
- else if (strcmp(err.message, "Operation not allowed") == 0)
+ else if (strcmp(err->message, "Operation not allowed") == 0)
ret = BLUETOOTH_ERROR_PERMISSION_DEINED;
else
ret = BLUETOOTH_ERROR_INTERNAL;
- dbus_error_free(&err);
+ 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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)
+ if (err) {
+ BT_ERR("Error = %s", err->message);
+ g_dbus_error_strip_remote_error(err);
+ if (strcmp(err->message, "NotConnected") == 0)
ret = BLUETOOTH_ERROR_NOT_CONNECTED;
- else if (strcmp(err.message, "Operation not allowed") == 0)
+ else if (strcmp(err->message, "Operation not allowed") == 0)
ret = BLUETOOTH_ERROR_IN_PROGRESS;
else
ret = BLUETOOTH_ERROR_INTERNAL;
- dbus_error_free(&err);
+ 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
BT_CHECK_ENABLED(return);
strcpy(buffer, "AT+XSAT=");
- /* Fix : OVERRUN */
- snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "%d,", app_id);
+ snprintf(buffer + strlen(buffer), sizeof(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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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;
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_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- 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_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) {
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_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);
+
+ g_variant_get(reply, "(b)", &hf_connected_from_bt_agent);
*hf_connected = hf_connected_from_bt_agent;
BT_DBG("%s", *hf_connected ? "Connected":"Disconnected");
- dbus_message_unref(reply);
-
+ g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
#include <sys/types.h>
#include <sys/socket.h>
-#include <dbus/dbus.h>
+#include <gio/gio.h>
+#include <glib.h>
#include <string.h>
+#include <gio/gunixfdlist.h>
#include "bluetooth-api.h"
#include "bt-common.h"
#define BLUEZ_HDP_DEVICE_INTERFACE "org.bluez.HealthDevice1"
#define BLUEZ_HDP_CHANNEL_INTERFACE "org.bluez.HealthChannel1"
-gboolean interface_exist = FALSE;
-
typedef struct {
char *obj_channel_path;
int fd;
bt_hdp_qos_type_t channel_type,
char **app_handle);
-static DBusHandlerResult __bt_hdp_internal_event_filter(DBusConnection *sys_conn,
- DBusMessage *msg,
- void *data);
+static void __bt_hdp_internal_event_filter(GDBusConnection *connection,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data);
-static void __bt_hdp_internal_handle_connect(DBusMessage *msg);
+static void __bt_hdp_internal_handle_connect(GVariant *parameters);
-static void __bt_hdp_internal_handle_disconnect(DBusMessage *msg);
+static void __bt_hdp_internal_handle_disconnect(GVariant *parameters,
+ const gchar *object_path);
-static void __bt_hdp_internal_handle_property_changed(DBusMessage *msg);
+static void __bt_hdp_internal_handle_property_changed(GVariant *parameters);
static int __bt_hdp_internal_add_filter(void);
static hdp_obj_info_t *__bt_hdp_internal_gslist_obj_find_using_path(const char *obj_channel_path);
/*Global Variables*/
-static DBusConnection *g_hdp_dus_conn;
+static GDBusConnection *g_hdp_dus_conn;
static GSList *g_app_list = NULL;
bt_hdp_qos_type_t channel_type,
char **app_handle)
{
- DBusMessage *msg;
- DBusMessage *reply;
+ GDBusProxy *proxy = NULL;
+ GVariant *reply = NULL;
+ GVariantBuilder *builder;
const char *svalue;
const char *key_type;
char *app_path;
hdp_app_list_t *list;
- DBusError err;
- DBusMessageIter iter;
- DBusMessageIter array_iter;
- DBusMessageIter entry;
- DBusMessageIter variant;
+ GError *err = NULL;
guint16 value;
- DBusConnection *conn;
+ GDBusConnection *conn;
int ret = BLUETOOTH_ERROR_NONE;
BT_DBG("+");
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- msg = dbus_message_new_method_call(BT_BLUEZ_NAME, "/org/bluez",
- BLUEZ_HDP_MANAGER_INTERFACE,
- "CreateApplication");
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ BT_BLUEZ_NAME,
+ "/org/bluez",
+ BLUEZ_HDP_MANAGER_INTERFACE,
+ NULL, &err);
- retv_if(msg == NULL, BLUETOOTH_ERROR_INTERNAL);
+ if (!proxy) {
+ BT_ERR("Unable to create proxy: %s", err->message);
+ g_clear_error(&err);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
- DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
- DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
- &array_iter);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
key_type = "DataType";
value = (guint16) data_type;
- dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY,
- NULL, &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key_type);
- dbus_message_iter_open_container(&entry,
- DBUS_TYPE_VARIANT, DBUS_TYPE_UINT16_AS_STRING, &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_UINT16, &value);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(&array_iter, &entry);
+ g_variant_builder_add(builder, "{sv}",
+ key_type, g_variant_new("q",
+ value));
key_type = "Role";
-
/*0-Source,1-Sink*/
svalue = (role == HDP_ROLE_SINK) ? "Sink" : "Source";
- dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY,
- NULL, &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key_type);
- dbus_message_iter_open_container(&entry,
- DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &svalue);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(&array_iter, &entry);
+ g_variant_builder_add(builder, "{sv}",
+ key_type, g_variant_new("s",
+ svalue));
key_type = "Description";
svalue = "Health Device";
- dbus_message_iter_open_container(&array_iter, DBUS_TYPE_DICT_ENTRY,
- NULL, &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key_type);
- dbus_message_iter_open_container(&entry,
- DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &svalue);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(&array_iter, &entry);
+ g_variant_builder_add(builder, "{sv}",
+ key_type, g_variant_new("s",
+ svalue));
if (role == HDP_ROLE_SOURCE) {
key_type = "ChannelType";
else if (channel_type == HDP_QOS_STREAMING)
svalue = "streaming";
- dbus_message_iter_open_container(&array_iter,
- DBUS_TYPE_DICT_ENTRY, NULL, &entry);
- dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
- &key_type);
- dbus_message_iter_open_container(&entry,
- DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING,
- &variant);
- dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING,
- &svalue);
- dbus_message_iter_close_container(&entry, &variant);
- dbus_message_iter_close_container(&array_iter, &entry);
+ g_variant_builder_add(builder, "{sv}",
+ key_type, g_variant_new("s",
+ svalue));
}
- dbus_message_iter_close_container(&iter, &array_iter);
+ reply = g_dbus_proxy_call_sync(proxy, "CreateApplication",
+ g_variant_new("(a{sv})", builder),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &err);
- dbus_error_init(&err);
-
- reply = dbus_connection_send_with_reply_and_block(
- conn, msg,
- -1, &err);
- dbus_message_unref(msg);
+ g_variant_builder_unref(builder);
+ g_object_unref(proxy);
if (!reply) {
BT_ERR(" HDP:dbus Can't create application");
-
- if (dbus_error_is_set(&err)) {
- BT_ERR("%s", err.message);
-
- if (g_strrstr(err.message, BT_ACCESS_DENIED_MSG))
+ if (err) {
+ BT_ERR("%s", err->message);
+ if (g_strrstr(err->message, BT_ACCESS_DENIED_MSG))
ret = BLUETOOTH_ERROR_ACCESS_DENIED;
else
ret = BLUETOOTH_ERROR_INTERNAL;
-
- dbus_error_free(&err);
+ g_clear_error(&err);
}
return ret;
}
- if (!dbus_message_get_args(reply, &err, DBUS_TYPE_OBJECT_PATH,
- &app_path, DBUS_TYPE_INVALID)) {
-
- BT_ERR(" HDP: Can't get reply arguments from Dbus");
+ g_variant_get(reply, "(&o)", &app_path);
+ BT_DBG("Created health application: %s", (char *)app_path);
- if (dbus_error_is_set(&err)) {
- BT_ERR("Error: %s", err.message);
- dbus_error_free(&err);
- }
+ ret = __bt_hdp_internal_add_filter();
- dbus_message_unref(reply);
- return BLUETOOTH_ERROR_INTERNAL;
+ if (ret != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Funtion failed");
+ return ret;
}
- dbus_message_unref(reply);
-
- BT_DBG("Created health application: %s", (char *)app_path);
-
list = g_new0(hdp_app_list_t, 1);
list->app_handle = (void *)g_strdup(app_path);
- *app_handle = (char *)list->app_handle;
+ *app_handle = list->app_handle;
+
g_app_list = g_slist_append(g_app_list, list);
- BT_DBG("app_handle: %s", (char *)list->app_handle);
+ g_variant_unref(reply);
+ return BLUETOOTH_ERROR_NONE;
+}
- ret = __bt_hdp_internal_add_filter();
+static int __bt_hdp_add_filter_subscribe_signal(GDBusConnection *conn,
+ gboolean subscribe)
+{
+ static guint subs_add_filter_id = 0;
- if (ret != BLUETOOTH_ERROR_NONE) {
- BT_ERR("Funtion failed");
- return ret;
- }
+ if (conn == NULL)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+ if (subscribe) {
+ if (subs_add_filter_id == 0) {
+ subs_add_filter_id = g_dbus_connection_signal_subscribe(
+ conn, NULL, BLUEZ_HDP_DEVICE_INTERFACE,
+ NULL, NULL, NULL, 0,
+ __bt_hdp_internal_event_filter, NULL, NULL);
+ }
+ } else {
+ if (subs_add_filter_id > 0) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_add_filter_id);
+ subs_add_filter_id = 0;
+ }
+ }
return BLUETOOTH_ERROR_NONE;
}
static int __bt_hdp_internal_add_filter(void)
{
- DBusError dbus_error;
-
BT_DBG("+");
/*Single process only one signal registration is required */
if (g_hdp_dus_conn) {
BT_ERR("g_hdp_dus_conn already exist");
- goto done;
+ return BLUETOOTH_ERROR_NONE;
}
- /* Add the filter for HDP client functions */
- dbus_error_init(&dbus_error);
-
- g_hdp_dus_conn = _bt_get_system_conn();
+ g_hdp_dus_conn = _bt_gdbus_get_system_gconn();
retv_if(g_hdp_dus_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- dbus_connection_add_filter(g_hdp_dus_conn,
- __bt_hdp_internal_event_filter, NULL, NULL);
-
- dbus_bus_add_match(g_hdp_dus_conn,
- "type='signal',interface=" BLUEZ_HDP_DEVICE_INTERFACE,
- &dbus_error);
-
- dbus_bus_add_match(g_hdp_dus_conn,
- "type='signal',interface=" BT_MANAGER_INTERFACE,
- &dbus_error);
-
- dbus_bus_add_match(g_hdp_dus_conn,
- "type='signal',interface=" BT_PROPERTIES_INTERFACE,
- &dbus_error);
- if (dbus_error_is_set(&dbus_error)) {
- BT_ERR("Fail to add dbus filter signal\n");
- dbus_error_free(&dbus_error);
- g_hdp_dus_conn = NULL;
- return BLUETOOTH_ERROR_INTERNAL;
- }
+ return __bt_hdp_add_filter_subscribe_signal(g_hdp_dus_conn, TRUE);
-done:
BT_DBG("-\n");
- return BLUETOOTH_ERROR_NONE;
-
}
-static void __bt_hdp_internal_handle_connected(DBusMessage *msg);
-
-
-static DBusHandlerResult __bt_hdp_internal_event_filter(DBusConnection *sys_conn,
- DBusMessage *msg, void *data)
+static void __bt_hdp_internal_event_filter(GDBusConnection *connection,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data)
{
- const char *path = dbus_message_get_path(msg);
-
- if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
- BT_DBG("Path = %s\n", path);
- if (path == NULL)
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
- if (dbus_message_is_signal(msg, BLUEZ_HDP_DEVICE_INTERFACE,
- "ChannelConnected"))
- __bt_hdp_internal_handle_connect(msg);
- else if (dbus_message_is_signal(msg, BLUEZ_HDP_DEVICE_INTERFACE,
- "ChannelDeleted"))
- __bt_hdp_internal_handle_disconnect(msg);
- else if (dbus_message_is_signal(msg, BLUEZ_HDP_DEVICE_INTERFACE,
- "PropertyChanged"))
- __bt_hdp_internal_handle_property_changed(msg);
- else if (dbus_message_is_signal(msg, BT_MANAGER_INTERFACE,
- "InterfacesAdded")) {
- interface_exist = TRUE;
- BT_DBG("InterfaceAdded");
- } else if (dbus_message_is_signal(msg, BT_MANAGER_INTERFACE,
- "InterfacesRemoved")) {
- interface_exist = FALSE;
- __bt_hdp_internal_handle_disconnect(msg);
- BT_DBG("InterfaceRemoved");
- } else if (dbus_message_is_signal(msg, BT_PROPERTIES_INTERFACE,
- "PropertiesChanged")) {
- BT_DBG("PropertyChanged");
- if(interface_exist)
- __bt_hdp_internal_handle_connected(msg);
- }
-
- return DBUS_HANDLER_RESULT_HANDLED;
-}
-
-static void __bt_hdp_internal_handle_connected(DBusMessage *msg)
-{
- DBusMessageIter iter, dict, entry, var;
- const char *path = NULL;
- const char *obj_channel_path = NULL;
- bt_user_info_t *user_info;
- int ret;
-
- if (dbus_message_iter_init(msg, &iter) == FALSE)
+ BT_DBG("Path = %s\n", object_path);
+ if (object_path == NULL || g_strcmp0(object_path, "/") == 0)
return;
- dbus_message_iter_get_basic(&iter, &path);
-
- BT_DBG("object path: %s", path);
-
- if(!g_strcmp0(path, "org.bluez.HealthDevice1")) {
- dbus_message_iter_next(&iter);
-
- if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
- return;
-
- dbus_message_iter_recurse(&iter, &dict);
- while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
- const char *interface;
-
- dbus_message_iter_recurse(&dict, &entry);
-
- if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
- break;
-
- dbus_message_iter_get_basic(&entry, &interface);
- dbus_message_iter_next(&entry);
- dbus_message_iter_recurse(&entry, &var);
-
- if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_OBJECT_PATH)
- break;
-
- dbus_message_iter_get_basic(&var, &obj_channel_path);
+ if (signal_name == NULL)
+ return;
- BT_DBG("interface: %s", interface);
- BT_DBG("object_path: %s", obj_channel_path);
+ if (strcasecmp(signal_name, "ChannelConnected") == 0)
+ __bt_hdp_internal_handle_connect(parameters);
- dbus_message_iter_next(&dict);
- }
+ else if (strcasecmp(signal_name, "ChannelDeleted") == 0)
+ __bt_hdp_internal_handle_disconnect(parameters, object_path);
- BT_INFO("Channel connected, Path = %s", obj_channel_path);
+ else if (strcasecmp(signal_name, "PropertyChanged") == 0)
+ __bt_hdp_internal_handle_property_changed(parameters);
- user_info = _bt_get_user_data(BT_COMMON);
- if (user_info == NULL || user_info->cb == NULL)
- return;
-
- ret = __bt_hdp_internal_acquire_fd(obj_channel_path);
- if (ret != BLUETOOTH_ERROR_NONE) {
- _bt_common_event_cb(BLUETOOTH_EVENT_HDP_CONNECTED,
- BLUETOOTH_ERROR_CONNECTION_ERROR, NULL,
- user_info->cb, user_info->user_data);
- }
- }
+ return;
}
-static void __bt_hdp_internal_handle_connect(DBusMessage *msg)
+static void __bt_hdp_internal_handle_connect(GVariant *parameters)
{
- const char *path = dbus_message_get_path(msg);
const char *obj_channel_path;
bt_user_info_t *user_info;
int ret;
BT_INFO("+********Signal - ChannelConnected******\n\n");
- BT_DBG("Path = %s", path);
-
- if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH,
- &obj_channel_path, DBUS_TYPE_INVALID)) {
- BT_ERR("Unexpected parameters in ChannelConnected signal");
- return;
- }
+ g_variant_get(parameters, "(&o)", &obj_channel_path);
BT_INFO("Channel connected, Path = %s", obj_channel_path);
BT_DBG("-");
}
-static void __bt_hdp_internal_handle_disconnect(DBusMessage *msg)
+static void __bt_hdp_internal_handle_disconnect(GVariant *parameters,
+ const gchar *object_path)
{
- const char *path = dbus_message_get_path(msg);
const char *obj_channel_path;
char address[BT_ADDRESS_STRING_SIZE] = { 0, };
bluetooth_device_address_t device_addr = { {0} };
bt_user_info_t *user_info;
BT_INFO("+********Signal - ChannelDeleted ******\n\n");
- BT_DBG("Path = %s", path);
+ BT_DBG("Path = %s", object_path);
- if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH,
- &obj_channel_path, DBUS_TYPE_INVALID)) {
- BT_ERR("Unexpected parameters in ChannelDeleted signal");
- return;
- }
+ g_variant_get(parameters, "(&o)", &obj_channel_path);
BT_INFO("Channel Deleted, Path = %s", obj_channel_path);
}
/*Since bluetoothd is not sending the ChannelDeleted signal */
- _bt_device_path_to_address(path, address);
+ _bt_convert_device_path_to_address(object_path, address);
_bt_convert_addr_string_to_type(device_addr.addr, address);
}
-static void __bt_hdp_internal_handle_property_changed(DBusMessage *msg)
+static void __bt_hdp_internal_handle_property_changed(GVariant *parameters)
{
- const char *path = dbus_message_get_path(msg);
- DBusMessageIter item_iter;
- DBusMessageIter value_iter;
- const char *property;
- const char *obj_main_channel_path;
+ char *property = NULL;
+ GVariant *value = NULL;
+ gsize len;
+ char *obj_main_channel_path = NULL;
+ GVariantIter *property_iter;
BT_DBG("+*******Signal - PropertyChanged*******\n");
- BT_DBG("Path = %s", path);
-
- dbus_message_iter_init(msg, &item_iter);
-
- if (dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_STRING) {
- BT_ERR("This is bad format dbus");
- return;
- }
- dbus_message_iter_get_basic(&item_iter, &property);
+ g_variant_get (parameters, "(a{sv})", &property_iter);
- ret_if(property == NULL);
-
- BT_DBG("Property (%s)\n", property);
-
- if (0 == g_strcmp0(property, "MainChannel")) {
- BT_INFO("Property MainChannel received");
-
- dbus_message_iter_next(&item_iter);
-
- dbus_message_iter_recurse(&item_iter, &value_iter);
-
- dbus_message_iter_get_basic(&value_iter,
- &obj_main_channel_path);
- BT_DBG("Path = %s", path);
-
- BT_DBG("Main Channel Path = %s", obj_main_channel_path);
+ while (g_variant_iter_loop(property_iter, "{sv}", &property, &value)) {
+ if (g_strcmp0("MainChannel", property) == 0) {
+ BT_INFO("Property MainChannel received");
+ obj_main_channel_path = g_variant_dup_string (value, &len);
+ BT_DBG("Main Channel Path = %s", obj_main_channel_path);
+ break;
+ }
}
+ g_free(property);
+ g_variant_unref(value);
+ g_free(obj_main_channel_path);
BT_DBG("-*************\n");
}
{
char address[BT_ADDRESS_STRING_SIZE] = { 0, };
bluetooth_device_address_t device_addr = { {0} };
- DBusMessageIter reply_iter;
- DBusMessageIter reply_iter_entry;
const char *property;
+ GVariant *value = NULL;
char *type_qos = NULL;
- char *device = NULL;;
- char *app_handle = NULL;;
- hdp_app_list_t *list = NULL;;
- DBusMessage *msg;
- DBusMessage *reply;
- DBusConnection *conn;
+ char *device = NULL;
+ char *app_handle = NULL;
+ hdp_app_list_t *list = NULL;
+ GDBusProxy *proxy = NULL;
+ GVariant *reply = NULL;
+ GDBusConnection *conn;
bt_hdp_connected_t conn_ind;
- DBusError err;
+ GError *err = NULL;
int fd;
bt_user_info_t *user_info;
char *dev_path;
+ GUnixFDList *out_fd_list;
+ int index;
+ GVariantIter *property_iter;
+ gsize len;
BT_DBG("+");
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- msg = dbus_message_new_method_call(BT_BLUEZ_NAME, path,
- BLUEZ_HDP_CHANNEL_INTERFACE,
- "Acquire");
-
- retv_if(msg == NULL, BLUETOOTH_ERROR_INTERNAL);
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ BT_BLUEZ_NAME,
+ path,
+ BLUEZ_HDP_CHANNEL_INTERFACE,
+ NULL, &err);
- dbus_error_init(&err);
+ if (!proxy) {
+ BT_ERR("Unable to create proxy: %s", err->message);
+ g_clear_error(&err);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- reply = dbus_connection_send_with_reply_and_block(conn, msg,
- -1, &err);
+ reply = g_dbus_proxy_call_with_unix_fd_list_sync (proxy,
+ "Acquire",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &out_fd_list,
+ NULL,
+ &err);
- dbus_message_unref(msg);
+ g_object_unref(proxy);
if (!reply) {
BT_ERR(" HDP:****** dbus Can't create application ****");
- if (dbus_error_is_set(&err)) {
- BT_ERR("%s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("%s", err->message);;
+ g_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- if (!dbus_message_get_args(reply, &err, DBUS_TYPE_UNIX_FD, &fd,
- DBUS_TYPE_INVALID)) {
- BT_ERR(" HDP:dbus Can't get reply arguments");
-
- if (dbus_error_is_set(&err)) {
- BT_ERR("%s", err.message);
- dbus_error_free(&err);
- }
- goto error;
- }
+ g_variant_get (reply, "(h)", &index);
+ fd = g_unix_fd_list_get(out_fd_list, index, NULL);
- dbus_message_unref(reply);
+ g_variant_unref(reply);
BT_DBG("File Descriptor = %d, Dev_path = %s \n", fd, path);
- msg = dbus_message_new_method_call(BT_BLUEZ_NAME, path,
- BT_PROPERTIES_INTERFACE, "GetAll");
- dev_path = g_strdup(BLUEZ_HDP_CHANNEL_INTERFACE);
- dbus_message_append_args(msg, DBUS_TYPE_STRING, &dev_path,
- DBUS_TYPE_INVALID);
- g_free(dev_path);
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ BT_BLUEZ_NAME,
+ path,
+ BT_PROPERTIES_INTERFACE,
+ NULL, &err);
- retv_if(msg == NULL, BLUETOOTH_ERROR_INTERNAL);
+ if (!proxy) {
+ BT_ERR("Unable to create proxy: %s", err->message);
+ g_clear_error(&err);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- dbus_error_init(&err);
+ dev_path = g_strdup(BLUEZ_HDP_CHANNEL_INTERFACE);
- reply = dbus_connection_send_with_reply_and_block(conn, msg,
- -1, &err);
+ reply = g_dbus_proxy_call_sync(proxy, "GetAll",
+ g_variant_new("(s)", dev_path),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &err);
- dbus_message_unref(msg);
+ g_free(dev_path);
+ g_object_unref(proxy);
if (!reply) {
BT_ERR(" HDP:dbus Can't get the reply");
- if (dbus_error_is_set(&err)) {
- BT_ERR("%s", err.message);
- dbus_error_free(&err);
+ if (err) {
+ BT_ERR("%s", err->message);;
+ g_clear_error(&err);
}
return BLUETOOTH_ERROR_INTERNAL;
}
- dbus_message_iter_init(reply, &reply_iter);
- if (dbus_message_iter_get_arg_type(&reply_iter) != DBUS_TYPE_ARRAY) {
- BT_ERR("Can't get reply arguments - DBUS_TYPE_ARRAY\n");
- goto error;
- }
+ g_variant_get (reply, "(a{sv})", &property_iter);
- dbus_message_iter_recurse(&reply_iter, &reply_iter_entry);
-
- /*Parse the dict */
- while (dbus_message_iter_get_arg_type(&reply_iter_entry) ==
- DBUS_TYPE_DICT_ENTRY) {
- DBusMessageIter dict_entry, dict_entry_val;
- dbus_message_iter_recurse(&reply_iter_entry, &dict_entry);
- dbus_message_iter_get_basic(&dict_entry, &property);
+ while (g_variant_iter_loop(property_iter, "{sv}", &property, &value)) {
BT_DBG("String received = %s\n", property);
if (g_strcmp0("Type", property) == 0) {
- dbus_message_iter_next(&dict_entry);
- dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
- if (dbus_message_iter_get_arg_type(&dict_entry_val) !=
- DBUS_TYPE_STRING)
- continue;
-
- dbus_message_iter_get_basic(&dict_entry_val, &type_qos);
-
+ type_qos = g_variant_dup_string (value, &len);
} else if (g_strcmp0("Device", property) == 0) {
- dbus_message_iter_next(&dict_entry);
- dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
- if (dbus_message_iter_get_arg_type(&dict_entry_val) !=
- DBUS_TYPE_OBJECT_PATH)
- continue;
-
- dbus_message_iter_get_basic(&dict_entry_val, &device);
-
+ device = g_variant_dup_string (value, &len);
} else if (g_strcmp0("Application", property) == 0) {
- dbus_message_iter_next(&dict_entry);
- dbus_message_iter_recurse(&dict_entry, &dict_entry_val);
- if (dbus_message_iter_get_arg_type(&dict_entry_val) !=
- DBUS_TYPE_OBJECT_PATH)
- continue;
-
- dbus_message_iter_get_basic(&dict_entry_val,
- &app_handle);
+ app_handle = g_variant_dup_string (value, &len);
}
- dbus_message_iter_next(&reply_iter_entry);
}
+ g_variant_unref(reply);
BT_DBG("QOS = %s, Device = %s, Apphandler = %s",
type_qos, device, app_handle);
info->watch_id = __bt_hdp_internal_watch_fd(fd, info->obj_channel_path);
list->obj_info = g_slist_append(list->obj_info, info);
- _bt_device_path_to_address(path, address);
+ _bt_convert_device_path_to_address(path, address);
_bt_convert_addr_string_to_type(device_addr.addr, address);
user_info->cb, user_info->user_data);
}
- dbus_message_unref(reply);
-
BT_DBG("Updated fd in the list*\n");
BT_DBG("-\n");
+ g_free(type_qos);
+ g_free(device);
+ g_free(app_handle);
return BLUETOOTH_ERROR_NONE;
- error:
- dbus_message_unref(reply);
+error:
+ g_free(type_qos);
+ g_free(device);
+ g_free(app_handle);
return BLUETOOTH_ERROR_INTERNAL;
}
ret_if(info == NULL);
/*Since bluetoothd is not sending the ChannelDeleted signal */
- _bt_device_path_to_address(path, address);
+ _bt_convert_device_path_to_address(path, address);
_bt_convert_addr_string_to_type(device_addr.addr, address);
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
BT_DBG("GIOCondition %d.............path = %s\n", cond, path);
+ g_io_channel_shutdown(gio, TRUE, NULL);
+ g_io_channel_unref(gio);
__bt_hdp_internal_handle_disconnect_cb(sk, path);
return FALSE;
}
BT_DBG("Received data of %d\n", act_read);
} else {
BT_ERR("Read failed.....\n");
- __bt_hdp_internal_handle_disconnect_cb(sk, path);
return FALSE;
}
hdp_app_list_t *list = l->data;
if (list) {
- BT_DBG("found app_handle=%s\n", (char *)list->app_handle);
if (0 == g_strcmp0((char *)list->app_handle,
(char *)app_handle))
return list;
static int __bt_hdp_internal_destroy_application(const char *app_handle)
{
- DBusMessage *msg;
- DBusMessage *reply;
- DBusError err;
- DBusConnection *conn;
+ GDBusProxy *proxy = NULL;
+ GVariant *reply = NULL;
+ GError *err = NULL;
+ GDBusConnection *conn;
int result = BLUETOOTH_ERROR_NONE;
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- msg = dbus_message_new_method_call(BT_BLUEZ_NAME, "/org/bluez",
- BLUEZ_HDP_MANAGER_INTERFACE, "DestroyApplication");
-
- retv_if(msg == NULL, BLUETOOTH_ERROR_INTERNAL);
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ BT_BLUEZ_NAME,
+ "/org/bluez",
+ BLUEZ_HDP_MANAGER_INTERFACE,
+ NULL, &err);
- dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, &app_handle,
- DBUS_TYPE_INVALID);
+ if (!proxy) {
+ BT_ERR("Unable to create proxy: %s", err->message);
+ g_clear_error(&err);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- dbus_error_init(&err);
+ reply = g_dbus_proxy_call_sync(proxy, "DestroyApplication",
+ g_variant_new("o", app_handle),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &err);
- reply = dbus_connection_send_with_reply_and_block(conn, msg,
- -1, &err);
- dbus_message_unref(msg);
+ g_object_unref(proxy);
if (!reply) {
BT_ERR(" HDP:dbus Can't Destroy application");
- if (dbus_error_is_set(&err)) {
- BT_ERR("%s", err.message);
-
- if (g_strrstr(err.message, BT_ACCESS_DENIED_MSG))
+ if (err) {
+ BT_ERR("%s", err->message);
+ if (g_strrstr(err->message, BT_ACCESS_DENIED_MSG))
result = BLUETOOTH_ERROR_ACCESS_DENIED;
else
result = BLUETOOTH_ERROR_INTERNAL;
-
- dbus_error_free(&err);
+ g_clear_error(&err);
}
-
return result ;
}
- dbus_message_unref(reply);
+ g_variant_unref(reply);
BT_DBG("Destroyed health application: %s", (char *)app_handle);
ret_if(g_hdp_dus_conn == NULL);
- dbus_connection_remove_filter(g_hdp_dus_conn,
- __bt_hdp_internal_event_filter, NULL);
+ __bt_hdp_add_filter_subscribe_signal(g_hdp_dus_conn, FALSE);
g_hdp_dus_conn = NULL; /*should not unref here, bcz no ++reff */
param);
g_free(dev_path);
+ g_free((void *)param->app_handle);
+ g_free(param);
+ g_object_unref(hdp_proxy);
return BLUETOOTH_ERROR_NONE;
-
}
static void __bt_hdp_disconnect_request_cb(GDBusProxy *hdp_proxy,
}
g_free(disconn_ind);
-
}
BT_EXPORT_API int bluetooth_hdp_disconnect(unsigned int channel_id,
param);
g_free(dev_path);
+ g_free(param);
+ g_object_unref(hdp_proxy);
return BLUETOOTH_ERROR_NONE;
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff