Remove independent header file from bluez-lib.
Change-Id: I1dd196612adedb104227b2fa3b379ac6e6b13756
Signed-off-by: Wu Jiangbo <jiangbox.wu@intel.com>
data->cb(shuffle_mode, data->user_data);
}
-static void bluez_nap_connection_changed(bool connected,
+static void bluez_nap_connection_changed(gboolean connected,
const char *remote_address,
const char *interface_name,
void *user_data)
data_node->user_data);
}
-
static void bluez_hdp_state_changed(int result,
const char *remote_address,
const char *app_id,
- bt_hdp_channel_type_e type,
+ enum hdp_channel_type type,
unsigned int channel,
void *user_data)
{
- struct hdp_connection_changed_cb_node *data =
- user_data;
+ struct hdp_connection_changed_cb_node *data = user_data;
+ bt_hdp_channel_type_e channel_type;
- if (app_id != NULL) {
- if (data->conn_cb)
- data->conn_cb(result, remote_address,
- app_id, type, channel,
- data->user_data);
- else if (data->disconn_cb)
- data->disconn_cb(result, remote_address,
- channel, data->user_data);
- }
+ if (app_id == NULL)
+ return;
+
+ if (type == HDP_CHANNEL_RELIABLE)
+ channel_type = BT_HDP_CHANNEL_TYPE_RELIABLE;
+ else
+ channel_type = BT_HDP_CHANNEL_TYPE_STREAMING;
+
+ if (data->conn_cb)
+ data->conn_cb(result, remote_address, app_id,
+ channel_type, channel, data->user_data);
+
+ if (data->disconn_cb)
+ data->disconn_cb(result, remote_address,
+ channel, data->user_data);
}
static void bluez_avrcp_target_state_changed(const char *remote_address,
static void bluez_audio_state_changed(int result,
gboolean connected,
const char *remote_address,
- bt_audio_profile_type_e type,
+ enum audio_profile_type type,
void *user_data)
{
struct audio_connection_state_changed_cb_node *data =
if (default_adapter == NULL)
return BT_ERROR_ADAPTER_NOT_FOUND;
- result = bluetooth_hdp_activate(data_type,
- HDP_ROLE_SINK, HDP_QOS_ANY, app_id);
+ result = bluez_hdp_activate(data_type,
+ HDP_ROLE_SINK, HDP_CHANNEL_ANY, app_id);
return result;
}
if (default_adapter == NULL)
return BT_ERROR_ADAPTER_NOT_FOUND;
- result = bluetooth_hdp_deactivate(app_id);
+ result = bluez_hdp_deactivate(app_id);
return result;
}
if (default_adapter == NULL)
return BT_ERROR_ADAPTER_NOT_FOUND;
- result = bluetooth_hdp_send_data(channel, data, size);
+ result = bluez_hdp_send_data(channel, data, size);
return result;
}
-int bt_hdp_connect_to_source(const char *remote_address,
- const char *app_id)
+int bt_hdp_connect_to_source(const char *remote_address, const char *app_id)
{
int result = BT_ERROR_NONE;
- bluetooth_device_address_t addr_hex = { {0,} };
DBG("");
if (remote_address == NULL)
return BT_ERROR_INVALID_PARAMETER;
- convert_address_to_hex(&addr_hex, remote_address);
-
- result = bluetooth_hdp_connect(app_id, HDP_QOS_ANY, &addr_hex);
+ result = bluez_hdp_connect(app_id, HDP_CHANNEL_ANY, remote_address);
return result;
}
int bt_hdp_disconnect(const char *remote_address, unsigned int channel)
{
int result = BT_ERROR_NONE;
- bluetooth_device_address_t addr_hex = { {0,} };
DBG("");
if (remote_address == NULL)
return BT_ERROR_INVALID_PARAMETER;
- convert_address_to_hex(&addr_hex, remote_address);
-
- result = bluetooth_hdp_disconnect(channel, &addr_hex);
+ result = bluez_hdp_disconnect(channel, remote_address);
return result;
}
#include <glib.h>
#include "common.h"
-#include "bluetooth.h"
-#include "bluetooth-api.h"
#define BT_GENERIC_AUDIO_UUID "00001203-0000-1000-8000-00805f9b34fb"
void bluez_unset_data_received_changed_cb(struct _bluez_device *device);
+enum hdp_channel_type {
+ HDP_CHANNEL_RELIABLE,
+ HDP_CHANNEL_STREAMING,
+ HDP_CHANNEL_ANY
+};
+
typedef void (*bluez_hdp_state_changed_t)(int result,
const char *remote_address,
const char *app_id,
- bt_hdp_channel_type_e type,
+ enum hdp_channel_type type,
unsigned int channel,
gpointer user_data);
gpointer user_data);
void bluez_unset_avrcp_target_cb();
-typedef void (*bluez_nap_connection_state_cb_t)(bool connected,
+typedef void (*bluez_nap_connection_state_cb_t)(gboolean connected,
const char *remote_address,
const char *interface_name,
gpointer user_data);
gpointer user_data);
void bluez_unset_nap_connection_state_cb(void);
+enum audio_profile_type {
+ AUDIO_TYPE_A2DP,
+};
+
typedef void (*bluez_audio_state_cb_t)(int result,
gboolean connected,
const char *remote_address,
- bt_audio_profile_type_e type,
+ enum audio_profile_type type,
void *user_data);
void bluez_set_audio_state_cb(
int bluez_media_player_set_properties(struct _bluez_adapter *adapter,
media_player_settings_t *properties);
-int bluetooth_hdp_activate(unsigned short data_type,
- bt_hdp_role_type_t role,
- bt_hdp_qos_type_t channel_type,
- char **app_handle);
+enum hdp_role_type {
+ HDP_ROLE_SOURCE,
+ HDP_ROLE_SINK
+};
+
+int bluez_hdp_activate(unsigned short data_type,
+ enum hdp_role_type role,
+ enum hdp_channel_type channel_type,
+ char **app_handle);
-int bluetooth_hdp_deactivate(const char *app_handle);
+int bluez_hdp_deactivate(const char *app_handle);
-int bluetooth_hdp_send_data(unsigned int channel_id,
- const char *buffer,
- unsigned int size);
+int bluez_hdp_send_data(unsigned int channel_id,
+ const char *buffer,
+ unsigned int size);
-int bluetooth_hdp_connect(const char *app_handle,
- bt_hdp_qos_type_t channel_type,
- const bluetooth_device_address_t *device_address);
+int bluez_hdp_connect(const char *app_handle,
+ enum hdp_channel_type channel_type,
+ const char *device_address);
-int bluetooth_hdp_disconnect(unsigned int channel_id,
- const bluetooth_device_address_t *device_address);
+int bluez_hdp_disconnect(unsigned int channel_id,
+ const char *device_address);
void hdp_internal_handle_disconnect(gpointer user_data,
GVariant *param);
#include <stdio.h>
#include <gio/gio.h>
-#include "bluetooth-api.h"
#ifndef TIZEN
#define DBG(fmt, arg...) printf("%s:%d %s()" fmt "\n", __FILE__, __LINE__, __func__, ## arg)
void convert_device_path_to_address(const gchar *device_path,
gchar *device_address);
-void convert_address_to_hex(bluetooth_device_address_t *addr_hex,
- const char *addr_str);
-
-void convert_addr_type_to_string(char *address,
- unsigned char *addr);
-
void device_path_to_address(const char *device_path,
char *device_address);
-void convert_addr_string_to_type(unsigned char *addr,
- const char *address);
-
GDBusConnection *get_system_lib_dbus_connect(void);
#endif
GSList *obj_info;
} hdp_app_list_t;
+struct bluez_hdp_connected_t {
+ const char *app_handle;
+ unsigned int channel_id;
+ enum hdp_channel_type type;
+ char *device_address;
+};
+
+struct bluez_hdp_disconnect_t {
+ unsigned int channel_id;
+ char *device_address;
+};
+
#define HDP_BUFFER_SIZE 1024
struct _bluez_device {
device_path_to_address(path, address);
if (device->hdp_state_changed_cb)
- device->hdp_state_changed_cb(BLUETOOTH_ERROR_NONE,
- address, NULL, 0, sk,
- device->hdp_state_changed_cb_data);
+ device->hdp_state_changed_cb(0, address, NULL, 0, sk,
+ device->hdp_state_changed_cb_data);
DBG(" Removed connection from list\n");
adapter = bluez_adapter_get_adapter(DEFAULT_ADAPTER_NAME);
if (adapter == NULL)
- return BT_ERROR_OPERATION_FAILED;
+ return FALSE;
device = bluez_adapter_get_device_by_path(adapter, path);
if (device == NULL)
- return BT_ERROR_OPERATION_FAILED;
+ return FALSE;
sk = g_io_channel_unix_get_fd(gio);
char *device_name = NULL;
char *app_handle = NULL;
hdp_app_list_t *list = NULL;
- bt_hdp_channel_type_e type = HDP_QOS_RELIABLE;
+ enum hdp_channel_type type = HDP_CHANNEL_RELIABLE;
hdp_obj_info_t *info;
gint fd = 0;
GVariant *val;
conn = get_system_lib_dbus_connect();
if (conn == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
if (msg_reply && g_dbus_message_get_message_type(msg_reply)
== G_DBUS_MESSAGE_TYPE_ERROR) {
DBG(" HDP:****** dbus Can't create application ****");
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
if (fd == 0) {
DBG("HDP:dbus Can't get reply arguments");
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
DBG(" HDP:dbus Can't get the reply");
DBG("error %s", error->message);
g_error_free(error);
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
if (NULL == type_qos || NULL == app_handle) {
DBG("Pasing failed\n");
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
type = (g_strcmp0(type_qos, "Reliable") == 0) ?
- HDP_QOS_RELIABLE : HDP_QOS_STREAMING;
+ HDP_CHANNEL_RELIABLE : HDP_CHANNEL_STREAMING;
list = hdp_internal_gslist_find_app_handler((void *)app_handle);
if (NULL == list) {
DBG("**** Could not locate the list for %s*****\n", app_handle);
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
DBG("Going to give callback\n");
- if (device)
- if (device->hdp_state_changed_cb)
- device->hdp_state_changed_cb(
- BLUETOOTH_ERROR_NONE,
- address, app_handle, type, fd,
- device->hdp_state_changed_cb_data);
+ if (device && device->hdp_state_changed_cb)
+ device->hdp_state_changed_cb(0, address, app_handle, type, fd,
+ device->hdp_state_changed_cb_data);
DBG("Updated fd in the list*\n");
DBG("-\n");
- ret = BT_ERROR_NONE;
+ ret = 0;
done:
DBG("error");
- if (device)
- if (device->hdp_state_changed_cb)
- device->hdp_state_changed_cb(
- BLUETOOTH_ERROR_CONNECTION_ERROR,
- address, app_handle, type, fd,
- device->hdp_state_changed_cb_data);
+ if (device && device->hdp_state_changed_cb)
+ device->hdp_state_changed_cb(-1, address, app_handle, type, fd,
+ device->hdp_state_changed_cb_data);
return ret;
}
device_path_to_address(device->object_path, address);
if (device->hdp_state_changed_cb)
- device->hdp_state_changed_cb(BLUETOOTH_ERROR_NONE, address,
- NULL, 0, info->fd, device->hdp_state_changed_cb_data);
+ device->hdp_state_changed_cb(0, address, NULL, 0, info->fd,
+ device->hdp_state_changed_cb_data);
DBG(" Removed connection from list\n");
static int hdp_internal_create_application(unsigned int data_type,
int role,
- bt_hdp_qos_type_t channel_type,
+ enum hdp_channel_type channel_type,
char **app_handle)
{
GVariantBuilder *opts;
connection = get_system_lib_dbus_connect();
if (connection == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
g_variant_new("s", "Health Device"));
if (role == HDP_ROLE_SOURCE) {
- if (channel_type == HDP_QOS_RELIABLE)
+ if (channel_type == HDP_CHANNEL_RELIABLE)
svalue = "Reliable";
- else if (channel_type == HDP_QOS_STREAMING)
+ else if (channel_type == HDP_CHANNEL_STREAMING)
svalue = "Streaming";
else
svalue = "";
if (error) {
DBG("error %s", error->message);
g_error_free(error);
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
g_app_list = g_slist_append(g_app_list, list);
- ret = BT_ERROR_NONE;
+ ret = 0;
done:
return ret;
}
-int bluetooth_hdp_activate(unsigned short data_type,
- bt_hdp_role_type_t role,
- bt_hdp_qos_type_t channel_type,
+int bluez_hdp_activate(unsigned short data_type,
+ enum hdp_role_type role,
+ enum hdp_channel_type channel_type,
char **app_handle)
{
- int result = BT_ERROR_NONE;
+ int result = 0;
DBG("");
- if (role == HDP_ROLE_SOURCE && channel_type == HDP_QOS_ANY) {
+ if (role == HDP_ROLE_SOURCE && channel_type == HDP_CHANNEL_ANY) {
DBG("For source, type is mandatory - Reliable/Streaming");
- return BT_ERROR_INVALID_PARAMETER;
+ return -1;
}
result = hdp_internal_create_application(data_type, role,
connection = get_system_lib_dbus_connect();
if (connection == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
if (error) {
DBG("error %s", error->message);
g_error_free(error);
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
g_idle_add(hdp_internal_destroy_application_cb,
(gpointer)app_handle);
- ret = BT_ERROR_NONE;
+ ret = 0;
done:
return ret;
}
-int bluetooth_hdp_deactivate(const char *app_handle)
+int bluez_hdp_deactivate(const char *app_handle)
{
return hdp_internal_destroy_application(app_handle);
}
-int bluetooth_hdp_send_data(unsigned int channel_id,
+int bluez_hdp_send_data(unsigned int channel_id,
const char *buffer,
unsigned int size)
{
if ((channel_id == 0) || (NULL == buffer) || (size == 0)) {
DBG("Invalid arguments..\n");
- return BT_ERROR_INVALID_PARAMETER;
+ return -1;
} else {
while (wbytes < size) {
written = write(channel_id, buffer + wbytes,
size - wbytes);
if (written <= 0) {
DBG("write failed..\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
wbytes += written;
}
}
- return BT_ERROR_NONE;
+ return 0;
}
static void hdp_connect_request_cb(GObject *source_object,
GVariant *result;
char *obj_connect_path;
GDBusConnection *conn;
- char address[BT_ADDRESS_STRING_SIZE] = { 0 };
- bt_hdp_connected_t *conn_ind = user_data;
+ struct bluez_hdp_connected_t *conn_ind = user_data;
bluez_adapter_t *adapter = NULL;
struct _bluez_device *device = NULL;
conn = get_system_lib_dbus_connect();
if (conn == NULL)
goto done;
- result = g_dbus_connection_call_finish(conn,
- res,
- &error);
+ result = g_dbus_connection_call_finish(conn, res, &error);
if (error) {
DBG("HDP connection Dbus Call Error: %s\n", error->message);
g_error_free(error);
if (adapter == NULL)
goto done;
- convert_addr_type_to_string(address,
- (unsigned char *)conn_ind->device_address.addr);
-
device = bluez_adapter_get_device_by_address(adapter,
- address);
+ conn_ind->device_address);
if (device == NULL)
goto done;
if (device->hdp_state_changed_cb)
- device->hdp_state_changed_cb(
- BLUETOOTH_ERROR_CONNECTION_ERROR,
- address, conn_ind->app_handle,
- conn_ind->type, 0,
+ device->hdp_state_changed_cb(-1,
+ conn_ind->device_address,
+ conn_ind->app_handle, conn_ind->type, 0,
device->hdp_state_changed_cb_data);
} else {
g_variant_get(result, "(o)", &obj_connect_path);
g_free(conn_ind);
}
-int bluetooth_hdp_connect(const char *app_handle,
- bt_hdp_qos_type_t channel_type,
- const bluetooth_device_address_t *device_address)
+int bluez_hdp_connect(const char *app_handle,
+ enum hdp_channel_type channel_type, const char *device_address)
{
- bt_hdp_connected_t *param;
- char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ struct bluez_hdp_connected_t *param;
char *dev_path = NULL;
char *role;
bluez_adapter_t *adapter = NULL;
adapter = bluez_adapter_get_adapter(DEFAULT_ADAPTER_NAME);
if (adapter == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
- if (channel_type == HDP_QOS_RELIABLE) {
+ if (channel_type == HDP_CHANNEL_RELIABLE) {
role = "Reliable";
- } else if (channel_type == HDP_QOS_STREAMING) {
+ } else if (channel_type == HDP_CHANNEL_STREAMING) {
role = "Streaming";
- } else if (channel_type == HDP_QOS_ANY) {
+ } else if (channel_type == HDP_CHANNEL_ANY) {
role = "Any";
} else {
DBG("Invalid channel_type %d", channel_type);
- return BT_ERROR_INVALID_PARAMETER;
+ return -1;
}
conn = get_system_lib_dbus_connect();
if (conn == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
- convert_addr_type_to_string(address,
- (unsigned char *)device_address->addr);
-
- DBG("create conection to %s", address);
+ DBG("create conection to %s", device_address);
dev_path = g_strdup_printf("/org/bluez/%s/dev_%s",
- DEFAULT_ADAPTER_NAME, address);
+ DEFAULT_ADAPTER_NAME, device_address);
if (dev_path == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
DBG("path: %s", dev_path);
- param = g_new0(bt_hdp_connected_t, 1);
+ param = g_new0(struct bluez_hdp_connected_t, 1);
param->app_handle = g_strdup(app_handle);
- memcpy(¶m->device_address, device_address,
- BLUETOOTH_ADDRESS_LENGTH);
+ param->device_address = g_strdup(device_address);
param->type = channel_type;
g_dbus_connection_call(conn, BLUEZ_NAME,
g_free(dev_path);
- ret = BT_ERROR_NONE;
+ ret = 0;
done:
return ret;
}
static void hdp_disconnect_request_cb(GObject *source_object,
GAsyncResult *res, gpointer user_data)
{
- bt_hdp_disconnected_t *disconn_ind = user_data;
- char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ struct bluez_hdp_connected_t *disconn_ind = user_data;
GError *error;
GDBusConnection *conn;
bluez_adapter_t *adapter = NULL;
if (adapter == NULL)
goto done;
- convert_addr_type_to_string(address,
- (unsigned char *)disconn_ind->device_address.addr);
device = bluez_adapter_get_device_by_address(adapter,
- address);
+ disconn_ind->device_address);
if (device == NULL)
goto done;
if (device->hdp_state_changed_cb)
- device->hdp_state_changed_cb(
- BLUETOOTH_ERROR_CONNECTION_ERROR,
- address, NULL,
+ device->hdp_state_changed_cb(-1,
+ disconn_ind->device_address, NULL,
0, disconn_ind->channel_id,
device->hdp_state_changed_cb_data);
} else {
g_free(disconn_ind);
}
-int bluetooth_hdp_disconnect(unsigned int channel_id,
- const bluetooth_device_address_t *device_address)
+int bluez_hdp_disconnect(unsigned int channel_id, const char *device_address)
{
- bt_hdp_disconnected_t *param;
- char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ struct bluez_hdp_connected_t *param;
char *dev_path = NULL;
bluez_adapter_t *adapter = NULL;
GDBusConnection *conn;
adapter = bluez_adapter_get_adapter(DEFAULT_ADAPTER_NAME);
if (adapter == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
info = hdp_internal_gslist_obj_find_using_fd(channel_id);
if (NULL == info) {
DBG("*** Could not locate the list for %d*****\n", channel_id);
- ret = BT_ERROR_INVALID_PARAMETER;
+ ret = -1;
goto done;
}
conn = get_system_lib_dbus_connect();
if (conn == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
- convert_addr_type_to_string(address,
- (unsigned char *)device_address->addr);
-
- DBG("create conection to %s", address);
+ DBG("create conection to %s", device_address);
dev_path = g_strdup_printf("/org/bluez/%s/dev_%s",
- DEFAULT_ADAPTER_NAME, address);
+ DEFAULT_ADAPTER_NAME, device_address);
if (dev_path == NULL) {
- ret = BT_ERROR_OPERATION_FAILED;
+ ret = -1;
goto done;
}
DBG("path: %s", dev_path);
- param = g_new0(bt_hdp_disconnected_t, 1);
+ param = g_new0(struct bluez_hdp_connected_t, 1);
param->channel_id = channel_id;
- memcpy(¶m->device_address, device_address,
- BLUETOOTH_ADDRESS_LENGTH);
+ param->device_address = g_strdup(device_address);
g_dbus_connection_call(conn, BLUEZ_NAME,
dev_path,
g_free(dev_path);
- ret = BT_ERROR_NONE;
+ ret = 0;
done:
return ret;
}
struct _bluez_object {
char *path_name;
- bt_audio_profile_type_e media_type;
+ enum audio_profile_type media_type;
GDBusObject *obj;
GList *interfaces;
GDBusProxy *properties_proxy;
DBG("sender_name = %s, signal_name = %s",
sender_name, signal_name);
if (strcasecmp(signal_name, "PeerConnected"))
- connected = true;
+ connected = TRUE;
else if (strcasecmp(signal_name, "PeerDisconnected"))
- connected = false;
+ connected = FALSE;
else
return;
if (g_strcmp0(iface_name, MEDIATRANSPORT_INTERFACE) == 0) {
gchar *uuid, *device_address;
gchar *device_path;
- bt_audio_profile_type_e type;
+ enum audio_profile_type type;
path = g_dbus_proxy_get_object_path(proxy);
DBG("uuid = %s", uuid);
if (g_strcmp0(uuid, BT_A2DP_SINK_UUID) == 0) {
- type = BT_AUDIO_PROFILE_TYPE_A2DP;
+ type = AUDIO_TYPE_A2DP;
object->media_type = type;
}
}
static int bluez_avrcp_set_interal_property(struct _bluez_adapter *adapter,
- int type,
- media_player_settings_t *properties)
+ int type, media_player_settings_t *properties)
{
int value;
gboolean shuffle;
val = g_variant_new("s", loopstatus_settings[value].property);
if (!bluez_set_property(adapter, "LoopStatus", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
break;
case SHUFFLE:
val = g_variant_new("b", shuffle);
if (!bluez_set_property(adapter, "Shuffle", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
break;
case PLAYBACKSTATUS:
val = g_variant_new("s", playback_status[value].property);
if (!bluez_set_property(adapter, "PlaybackStatus", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
break;
case POSITION:
val = g_variant_new("x", value);
if (!bluez_set_property(adapter, "Position", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
break;
default:
DBG("Invalid Type\n");
- return BT_ERROR_INVALID_PARAMETER;
+ return -1;
}
- return BT_SUCCESS;
+ return -1;
}
int bluez_media_player_set_track_info(struct _bluez_adapter *adapter,
val = g_variant_new("s", meta_data->title);
if (!bluez_set_metadata(adapter, "xesam:title", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
}
if (!bluez_set_metadata(adapter, "xesam:artist",
val_array)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
}
val = g_variant_new("s", meta_data->album);
if (!bluez_set_metadata(adapter, "xesam:album", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
}
if (!bluez_set_metadata(adapter, "xesam:genre",
val_array)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
}
if (!bluez_set_metadata(adapter, "xesam:trackNumber",
val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
}
val = g_variant_new("x", meta_data->duration);
if (!bluez_set_metadata(adapter, "mpris:length", val)) {
DBG("Error sending the PropertyChanged signal\n");
- return BT_ERROR_OPERATION_FAILED;
+ return -1;
}
}
- return BT_SUCCESS;
+ return -1;
}
int bluez_media_player_change_property(struct _bluez_adapter *adapter,
break;
default:
DBG("Invalid Type\n");
- return BT_ERROR_INVALID_PARAMETER;
+ return -1;
}
ret = bluez_avrcp_set_interal_property(adapter,
{
if (bluez_avrcp_set_interal_property(adapter,
- LOOPSTATUS, properties) != 1) {
- return BT_ERROR_OPERATION_FAILED;
- }
+ LOOPSTATUS, properties) != 1)
+ return -1;
if (bluez_avrcp_set_interal_property(adapter,
- SHUFFLE, properties) != 1) {
- return BT_ERROR_OPERATION_FAILED;
- }
+ SHUFFLE, properties) != 1)
+ return -1;
if (bluez_avrcp_set_interal_property(adapter,
- PLAYBACKSTATUS,
- properties) != 1) {
- return BT_ERROR_OPERATION_FAILED;
- }
+ PLAYBACKSTATUS, properties) != 1)
+ return -1;
if (bluez_avrcp_set_interal_property(adapter,
- POSITION, properties) != 1) {
- return BT_ERROR_OPERATION_FAILED;
- }
+ POSITION, properties) != 1)
+ return -1;
- return BT_SUCCESS;
+ return 0;
}
static void bluez_device_connect_cb(GObject *source_object,
struct _bluez_object *object;
GList *list, *next;
int length;
- gboolean is_type = false;
+ gboolean is_type = FALSE;
gchar device_address[BT_ADDRESS_STRING_SIZE];
DBG("");
length = g_list_length(bluez_object_list);
if (length == 0)
- return false;
+ return FALSE;
for (list = g_list_first(bluez_object_list); list; list = next) {
next = g_list_next(list);
(gchar *)device_address);
if (!g_strcmp0(remote_address, device_address) &&
- object->media_type == BT_AUDIO_PROFILE_TYPE_A2DP) {
- is_type = true;
+ object->media_type == AUDIO_TYPE_A2DP) {
+ is_type = TRUE;
break;
}
}
g_free(reply_data);
}
-void convert_address_to_hex(bluetooth_device_address_t *addr_hex,
- const char *addr_str)
-{
- int i = 0;
- unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = { 0, };
-
- if (addr_str == NULL)
- return;
-
- i = sscanf(addr_str, "%X:%X:%X:%X:%X:%X", &addr[0], &addr[1],
- &addr[2], &addr[3], &addr[4], &addr[5]);
-
- if (i != BLUETOOTH_ADDRESS_LENGTH)
- DBG("Invalid format string - %s", addr_str);
-
- for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++)
- addr_hex->addr[i] = (unsigned char)addr[i];
-}
-
-void convert_addr_type_to_string(char *address,
- unsigned char *addr)
-{
- if (address == NULL && addr == NULL)
- return;
-
- snprintf(address, BLUETOOTH_ADDRESS_LENGTH,
- "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
- addr[0], addr[1], addr[2],
- addr[3], addr[4], addr[5]);
-}
-
void device_path_to_address(const char *device_path, char *device_address)
{
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
}
}
-void convert_addr_string_to_type(unsigned char *addr,
- const char *address)
-{
- int i;
- char *ptr = NULL;
-
- if (address == NULL || addr == NULL)
- return;
-
- for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++) {
- addr[i] = strtol(address, &ptr, 16);
- if (ptr != NULL) {
- if (ptr[0] != ':')
- return;
-
- address = ptr + 1;
- }
- }
-}
-
GDBusConnection *get_system_lib_dbus_connect(void)
{
GError *error = NULL;
if (relay_agent == NULL) {
DBG("relay_agent == NULL");
- return false;
+ return FALSE;
}
if (g_strcmp0(property_name, "LoopStatus") == 0) {
DBG("");
- result = bluetooth_hdp_activate(1,
- HDP_ROLE_SINK, HDP_QOS_ANY, &app_id);
+ result = bluez_hdp_activate(1,
+ HDP_ROLE_SINK, HDP_CHANNEL_ANY, &app_id);
DBG("result = %d app_id = %s", result, app_id);
DBG("app_id = %s", app_id);
- result = bluetooth_hdp_deactivate((const char *)(app_id));
+ result = bluez_hdp_deactivate((const char *)(app_id));
DBG("result = %d", result);
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff