static int __bt_fill_device_list(GArray *out_param2, GPtrArray **dev_list)
{
- int i;
+ unsigned int i;
guint size;
bluetooth_device_info_t info;
char uuid[BLUETOOTH_UUID_STRING_MAX];
int result;
guint size;
- int i;
+ unsigned int i;
BT_CHECK_PARAMETER(profile_uuid, return);
BT_CHECK_PARAMETER(addr_list, return);
return BLUETOOTH_ERROR_NONE;
}
-BT_EXPORT_API int bluetooth_hf_initiate_call(char *number)
+BT_EXPORT_API int bluetooth_hf_initiate_call(const char *number)
{
GVariant *reply = NULL;
GError *err = NULL;
int _bt_copy_utf8_string(char *dest, const char *src, unsigned int length)
{
- int i;
+ unsigned int i;
const char *p = src;
char *next;
int count;
static GDBusProxy *profile_gproxy;
-static GDBusConnection *gconn;
+static GDBusConnection *gconn_g;
static int latest_id = -1;
#define BT_RFCOMM_ID_MAX 245
static gboolean id_used[BT_RFCOMM_ID_MAX];
__new_connection_method,
NULL,
NULL,
+ {0}
};
void _bt_swap_addr(unsigned char *dst, const unsigned char *src)
static GDBusConnection *__get_gdbus_connection()
{
- if (gconn == NULL)
- gconn = g_bus_get_private_conn();
+ if (gconn_g == NULL)
+ gconn_g = g_bus_get_private_conn();
- return gconn;
+ return gconn_g;
}
static GDBusProxy *__bt_gdbus_get_profile_proxy(void)
GError *err = NULL;
object_path = _bt_get_device_object_path(address);
if (object_path == NULL) {
- GVariant *ret = NULL;
BT_ERR("No searched device");
adapter_proxy = __bt_gdbus_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
return BT_DPM_ALLOWED;
}
-static bt_dpm_status_e _bt_check_dpm_blacklist_uuid(char *uuid)
+static bt_dpm_status_e _bt_check_dpm_blacklist_uuid(const char *uuid)
{
bt_dpm_status_e bt_dpm_status = BT_DPM_ALLOWED;
bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
}
if (g_strcmp0(BT_OPP_UUID, uuid) == 0) {
- bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
+ dpm_status = BLUETOOTH_DPM_ALLOWED;
bluetooth_dpm_get_data_transfer_state(&dpm_status);
return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
}
BT_DBG("Type: %s", g_variant_get_type_string(parameters));
if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
- bt_pbap_connected_t connected = { { { 0 }, }, };
+ bt_pbap_connected_t connected;
char *address = NULL;
g_variant_get(parameters, "(i&s)", &result, &address);
result, &connected,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
- bt_pbap_connected_t disconnected = { { { 0 }, }, };
+ bt_pbap_connected_t disconnected;
char *address = NULL;
g_variant_get(parameters, "(i&s)", &result, &address);
result, &disconnected,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
- bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
+ bt_pbap_phonebook_size_t pb_size;
char *address = NULL;
int size = 0;
result, &pb_size,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
- bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
+ bt_pbap_phonebook_pull_t pb_pull;
char *address = NULL;
char *vcf_file = NULL;
int success = -1;
result, &pb_pull,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
- bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
+ bt_pbap_vcard_list_t vc_list;
char *address = NULL;
gsize count = 0;
gchar **list = NULL;
GVariant *string_var;
int success = -1;
- int i = 0;
+ unsigned int i = 0;
g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
g_variant_unref(string_var);
//free lists
} else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
- bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
+ bt_pbap_vcard_pull_t vc_pull;
char *address = NULL;
char *vcf_file = NULL;
int success = -1;
result, &vc_pull,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
- bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
+ bt_pbap_phonebook_search_list_t vc_list;
char *address = NULL;
gsize count = 0;
gchar **list = NULL;
GVariant *string_var;
int success = -1;
- int i = 0;
+ unsigned int i = 0;
g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
g_variant_unref(var_data);
}
- if (handle && (call_count == g_list_length(handle->list))) {
+ if (handle && (call_count == (int)g_list_length(handle->list))) {
handle->count = call_count;
_bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
result, handle,
{
gchar *gp_path = NULL;
char **path = NULL;
- int i;
+ unsigned int i;
if (gp->len == 0)
return NULL;
GVariant *value = NULL;
GVariant *result = NULL;
GDBusConnection *g_conn;
- int i, ret = BLUETOOTH_ERROR_NONE;
+ unsigned int i;
+ int ret = BLUETOOTH_ERROR_NONE;
const char *uuid = NULL;
gsize len = 0;
GVariantIter *desc_value_iter, *property_iter;
__bt_gatt_desc_method_call,
NULL,
NULL,
+ { 0 }
};
static const GDBusInterfaceVTable char_interface_vtable = {
__bt_gatt_char_method_call,
NULL,
NULL,
+ { 0 }
};
static const GDBusInterfaceVTable serv_interface_vtable = {
NULL,
NULL,
NULL,
+ { 0 }
};
static const GDBusInterfaceVTable manager_interface_vtable = {
__bt_gatt_manager_method_call,
NULL,
- NULL
+ NULL,
+ { 0 }
};
static GDBusNodeInfo *__bt_gatt_create_method_node_info(
if (!info)
return NULL;
- if (sock_fd == info->fd)
+ if ((int)sock_fd == info->fd)
return info;
}
}
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
bt_hdp_disconnected_t disconn_info;
- bt_user_info_t *user_info;
hdp_app_list_t *list;
BT_DBG("GIOCondition %d", cond);
const char *buffer,
unsigned int size)
{
- int wbytes = 0;
+ unsigned int wbytes = 0;
int written = 0;
hdp_obj_info_t *info;
int result;
}
static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
- gpointer data)
+ gpointer user_data)
{
- hid_connected_device_info_t *info = data;
+ hid_connected_device_info_t *info = user_data;
GIOStatus status = G_IO_STATUS_NORMAL;
char buffer[20];
gsize len = 0;
default: {
BT_INFO("unsupported HIDP control message");
BT_ERR("Send Handshake Message");
- guint8 type = BT_HID_TRANS_HANDSHAKE |
+ guint8 type1 = BT_HID_TRANS_HANDSHAKE |
BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST;
data.type = HTYPE_TRANS_UNKNOWN;
int fd = g_io_channel_unix_get_fd(chan);
- int bytes = write(fd, &type, sizeof(type));
+ int bytes = write(fd, &type1, sizeof(type1));
BT_INFO("Bytes Written %d", bytes);
break;
}
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
- if (_bt_check_dpm(BT_DPM_UUID, BT_HID_UUID) == BT_DPM_RESTRICTED) {
+ if (_bt_check_dpm(BT_DPM_UUID, (void *)BT_HID_UUID) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist uuid");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
continue;
if (cmsg_ptr->cmsg_type == SCM_RIGHTS) {
- int *desc = (int *)CMSG_DATA(cmsg_ptr);
+ //int *desc = (int *)CMSG_DATA(cmsg_ptr);
int count
= ((cmsg_ptr->cmsg_len - CMSG_LEN(0)) / sizeof(int));
continue;
}
- sock_fd = desc[0];
+ //sock_fd = desc[0];
+ memcpy(&sock_fd, CMSG_DATA(cmsg_ptr), sizeof(sock_fd));
BT_DBG("Remote client fd: %d", sock_fd);
}
}
__bt_telephony_method,
NULL,
NULL,
+ {0}
};
static int __bt_telephony_get_error(const char *error_message)
break;
}
break;
+ default:
+ break;
}
+
BT_DBG("[%d]", flag);
FN_END;
return flag;
device_class = g_variant_get_uint32(value);
BT_DBG("Device Class: %d", device_class);
} else if (!g_strcmp0(key, "UUID")) {
- int i = 0;
+ unsigned int i = 0;
uuids = (gchar **)g_variant_get_strv(value, &len);
BT_DBG_UUID(uuids, len, i);
} else if (!g_strcmp0(key, "Address")) {
BT_EXPORT_API int bluetooth_telephony_call_swapped(void *call_list,
unsigned int call_count)
{
- int i;
+ unsigned int i;
int ret;
GList *list = call_list;
bt_telephony_call_status_info_t *call_status;
break;
}
case OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE: {
- BT_INFO("OAL Event: Advertising Params updated");
+ BT_INFO("OAL Event: Advertising Params updated");
break;
}
case OAL_EVENT_BLE_DISCOVERY_STARTED: {
unsigned short max_response, unsigned short duration, unsigned int mask);
static void __bt_adapter_discovery_state_change_callback(int bt_discovery_status);
static gboolean __bt_is_service_request_present(int service_function);
-#ifdef TIZEN_MOBILE
+#ifndef TIZEN_TV
static void __bt_set_visible_mode(void);
-#endif
static void __bt_set_local_name(void);
+#endif
/* Initialize BT stack (Initialize OAL layer) */
int _bt_stack_init(void)
BT_DBG("-");
}
-static int __bt_init_profiles()
+int _bt_init_profiles()
{
int ret;
return BLUETOOTH_ERROR_NONE;
}
+int _bt_cleanup_profiles(void)
+{
+ /* TODO: Cleanup bluetooth profiles */
+ _bt_hidhost_deinitialize();
+ _bt_socket_deinit();
+#if 0
+ /* TODO: Cleanup bluetooth audio profiles */
+ //_bt_audio_deinitialize(BT_A2DP_SOURCE_MODULE);
+ //_bt_audio_deinitialize(BT_AVRCP_MODULE);
+ //_bt_audio_deinitialize(BT_A2DP_SINK_MODULE);
+ //_bt_audio_deinitialize(BT_AG_MODULE);
+ //_bt_audio_deinitialize(BT_AVRCP_CTRL_MODULE);
+ //_bt_audio_deinitialize(BT_AUDIO_ALL_MODULE);
+#endif
+ _bt_hdp_deinit();
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
/* OAL post initialization handler */
static void __bt_post_oal_init(void)
{
int status = VCONFKEY_BT_STATUS_OFF;
BT_DBG("OAL initialized, Init profiles..");
- ret = __bt_init_profiles();
+ ret = _bt_init_profiles();
if (ret != BLUETOOTH_ERROR_NONE)
BT_ERR("Bluetooth profile init error: %d", ret);
if (ret != BLUETOOTH_ERROR_NONE)
BT_ERR("_bt_enable_adapter failed with error: %d", ret);
}
-
- return;
}
/* OAL initialization handler */
g_array_append_vals(out_param, user_data, size);
break;
case BT_IS_SERVICE_USED: {
- int i;
+ unsigned int i;
gboolean used = FALSE;
unsigned char *uuid;
char uuid_str[BT_UUID_STRING_SIZE];
if (NULL != req_info->user_data)
continue;
- BT_DBG("Total num of bonded devices = [%d]", count);
+ BT_DBG("BT_GET_BONDED_DEVICES: count = [%d]", count);
/* No bonded devices, return method invocation */
if (0 == count || !addr_list)
break;
}
}
+#ifndef TIZEN_TV
+static void __bt_phone_name_changed_cb(keynode_t *node, void *data)
+{
+ char *phone_name = NULL;
+ char *ptr = NULL;
+
+ if (node == NULL)
+ return;
+
+ if (vconf_keynode_get_type(node) == VCONF_TYPE_STRING) {
+ phone_name = vconf_keynode_get_str(node);
+
+ if (phone_name && strlen(phone_name) != 0) {
+ if (!g_utf8_validate(phone_name, -1,
+ (const char **)&ptr))
+ *ptr = '\0';
+
+ _bt_set_local_name(phone_name);
+ }
+ }
+}
+#endif
+
/* Request return handlings */
static gboolean __bt_adapter_post_set_enabled(gpointer user_data)
{
BT_INFO("__bt_adapter_post_set_enabled>>");
-#ifdef TIZEN_MOBILE
+#ifndef TIZEN_TV
__bt_set_visible_mode();
+
+ /* add the vconf noti handler */
+ if (0 != vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
+ (vconf_callback_fn)__bt_phone_name_changed_cb, NULL))
+ BT_ERR("DEVICE_NAME key changed notification registration failed");
+
+ __bt_set_local_name();
#else
-#ifdef TIZEN_TV
if (BLUETOOTH_ERROR_NONE != _bt_set_discoverable_mode(
BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE, 0))
BT_ERR("Fail to set discoverable mode");
#endif
-#endif
- __bt_set_local_name();
/* Get All properties */
if (OAL_STATUS_SUCCESS != adapter_get_properties())
static gboolean __bt_adapter_post_set_disabled(gpointer user_data)
{
BT_INFO("_bt_adapter_post_set_disabled>>");
+
+#ifndef TIZEN_TV
/* Add Adapter disabled post processing codes */
+ if (vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
+ (vconf_callback_fn)__bt_phone_name_changed_cb) != 0)
+ BT_ERR("vconf_ignore_key_changed failed");
+#endif
+
return FALSE;
}
/* Update Bluetooth Status to notify other modules */
if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
- BT_ERR("Set vconf failed\n");
+ BT_ERR("Set vconf failed");
/* TODO:Add timer function to handle any further post processing */
g_idle_add((GSourceFunc)__bt_adapter_post_set_disabled, NULL);
g_variant_new("(i)", result));
}
-
static void __bt_adapter_state_set_status(bt_status_t status)
{
BT_INFO("adapter_status changed [%d] -> [%d]", adapter_state, status);
BT_DBG("");
switch (adapter_state) {
- case BT_ACTIVATING:
- {
+ case BT_ACTIVATING: {
BT_INFO("Adapter is currently in activating state, state [%d]",
adapter_state);
if (enable) {
}
break;
}
- case BT_ACTIVATED:
- {
+ case BT_ACTIVATED: {
BT_INFO("Adapter is currently in activated state, state [%d]",
adapter_state);
if (enable) {
}
break;
}
- case BT_DEACTIVATING:
- {
+ case BT_DEACTIVATING: {
BT_INFO("Adapter is currently in deactivating state, state [%d]",
adapter_state);
if (!enable) {
}
break;
}
- case BT_DEACTIVATED:
- {
+ case BT_DEACTIVATED: {
BT_INFO("Adapter is currently in deactivated state, state [%d]",
adapter_state);
if (!enable) {
}
break;
}
+ default:
+ BT_ERR("Unknown state: %d", adapter_state);
+ break;
}
+
if (enable && result == BLUETOOTH_ERROR_NONE) {
/* Adapter enable request is successful, setup event handlers */
_bt_service_register_event_handler_callback(
result = BLUETOOTH_ERROR_INTERNAL;
} else {
BT_ERR("Start Discovery Triggered successfully");
- __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STARTING);
+ __bt_adapter_update_discovery_status(ADAPTER_DISCOVERY_STARTING);
result = BLUETOOTH_ERROR_NONE;
}
}
}
break;
}
+ default:
+ BT_ERR("Unknown state: %d", adapter_discovery_state);
+ break;
}
BT_DBG("-");
}
}
-#ifdef TIZEN_MOBILE
+#ifndef TIZEN_TV
static void __bt_set_visible_mode(void)
{
int timeout = 0;
}
#endif
}
-#endif
static void __bt_set_local_name(void)
{
}
free(phone_name);
}
+#endif
static void __bt_audio_device_property_event_handler(event_dev_properties_t *event)
{
GSList *l;
- int count;
+ unsigned int count;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bt_pending_audio_conn_t *info = NULL;
int value = BLUETOOTH_ERROR_NONE;
if (info && g_strcmp0(info->address, address) == 0 && info->search_status == SERVICE_SEARCH_STARTED) {
BT_INFO("Service searching is ongoing for addr [%s], Services received for the same!", info->address);
info->search_status = SERVICE_SEARCH_DONE;
- for(count=0; count < rem_info->uuid_count; count++) {
+ for(count = 0; count < rem_info->uuid_count; count++) {
BT_INFO("Device [%s] has UUID [%s]", address, rem_info->uuids[count]);
if (g_strcmp0(A2DP_SINK_UUID, rem_info->uuids[count]) == 0 && (info->conn_req_type == BT_AUDIO_ALL) ) {
BT_INFO("Device supports A2DP Sink Profile");
#include <bt-service-hf.h>
#include <bt-service-event.h>
-void static __bt_hf_handle_audio_disconnection_state(bt_address_t *address)
+static void __bt_hf_handle_audio_disconnection_state(bt_address_t *address)
{
BT_DBG("+");
GVariant *param;
" </interface>"
"</node>";
-GDBusNodeInfo *node_info = NULL;
+GDBusNodeInfo *node_info_g = NULL;
static void __bt_service_method(GDBusConnection *connection,
const gchar *sender,
__bt_service_method,
NULL,
NULL,
+ {0}
};
int __bt_bluez_request(int function_name,
switch (function_name) {
/*TODO*/
+ default:
+ break;
}
FN_END;
switch (function_name) {
/*TODO*/
+ default:
+ break;
}
return result;
switch (function_name) {
/*TODO*/
+ default:
+ break;
}
return result;
gboolean result = TRUE;
char *client_creds = NULL;
char *user_creds = NULL;
- char *client_session = "";
+ const char *client_session = "";
enum cynara_client_creds client_creds_method = CLIENT_METHOD_SMACK;
enum cynara_user_creds user_creds_method = USER_METHOD_UID;
char err_msg[256] = {0, };
if (owner_id == 0)
goto fail;
- node_info = __bt_service_create_method_node_info(
+ node_info_g = __bt_service_create_method_node_info(
bt_service_introspection_xml);
- if (node_info == NULL)
+ if (node_info_g == NULL)
goto fail;
- result = __bt_service_register_object(conn, node_info, TRUE);
- g_dbus_node_info_unref(node_info);
- node_info = NULL;
+ result = __bt_service_register_object(conn, node_info_g, TRUE);
+ g_dbus_node_info_unref(node_info_g);
+ node_info_g = NULL;
if (result != BLUETOOTH_ERROR_NONE)
goto fail;
g_object_unref(bt_service_conn);
bt_service_conn = NULL;
}
- if (node_info) {
- g_dbus_node_info_unref(node_info);
- node_info = NULL;
+ if (node_info_g) {
+ g_dbus_node_info_unref(node_info_g);
+ node_info_g = NULL;
}
if (owner_id > 0) {
g_bus_unown_name(owner_id);
gboolean _bt_agent_is_hid_keyboard(unsigned int dev_class)
{
switch ((dev_class & 0x1f00) >> 8) {
- case 0x05:
- switch ((dev_class & 0xc0) >> 6) {
- case 0x01:
- /* input-keyboard" */
- return TRUE;
- }
+ case 0x05:
+ switch ((dev_class & 0xc0) >> 6) {
+ case 0x01:
+ /* input-keyboard" */
+ return TRUE;
+ default:
break;
+ }
+ break;
+ default:
+ break;
}
return FALSE;
int i;
FILE *fp;
long size;
- size_t result;
+ long result;
BT_DBG("+");
return FALSE;
switch ((dev_class & 0x1f00) >> 8) {
- case 0x04:
- switch ((dev_class & 0xfc) >> 2) {
- case 0x01:
- case 0x02:
- /* Headset */
- is_headset = TRUE;
- break;
- case 0x06:
- /* Headphone */
- is_headset = TRUE;
- break;
- case 0x0b: /* VCR */
- case 0x0c: /* Video Camera */
- case 0x0d: /* Camcorder */
- break;
- default:
- /* Other audio device */
- is_headset = TRUE;
- break;
- }
+ case 0x04:
+ switch ((dev_class & 0xfc) >> 2) {
+ case 0x01:
+ case 0x02:
+ /* Headset */
+ is_headset = TRUE;
+ break;
+ case 0x06:
+ /* Headphone */
+ is_headset = TRUE;
+ break;
+ case 0x0b: /* VCR */
+ case 0x0c: /* Video Camera */
+ case 0x0d: /* Camcorder */
+ break;
+ default:
+ /* Other audio device */
+ is_headset = TRUE;
break;
- case 0x05:
- switch (dev_class & 0xff) {
- case 0x80: /* 0x80: Pointing device(Mouse) */
- is_mouse = TRUE;
- break;
-
- case 0x40: /* 0x40: input device (BT keyboard) */
- /* Get the LAP(Lower Address part) */
- g_strlcpy(lap_address, address, sizeof(lap_address));
-
- /* Need to Auto pair the blacklisted Keyboard */
- if (_bt_agent_is_device_blacklist(lap_address, name) != TRUE) {
- BT_DBG("Device is not black listed\n");
- return FALSE;
- } else {
- BT_ERR("Device is black listed\n");
- return TRUE;
- }
+ }
+ break;
+ case 0x05:
+ switch (dev_class & 0xff) {
+ case 0x80: /* 0x80: Pointing device(Mouse) */
+ is_mouse = TRUE;
+ break;
+
+ case 0x40: /* 0x40: input device (BT keyboard) */
+ /* Get the LAP(Lower Address part) */
+ g_strlcpy(lap_address, address, sizeof(lap_address));
+
+ /* Need to Auto pair the blacklisted Keyboard */
+ if (_bt_agent_is_device_blacklist(lap_address, name) != TRUE) {
+ BT_DBG("Device is not black listed\n");
+ return FALSE;
+ } else {
+ BT_ERR("Device is black listed\n");
+ return TRUE;
}
+ break;
+ default:
+ break;
+ }
+ default:
+ break;
}
if ((!is_headset) && (!is_mouse))
dev_info->uuid_count = oal_device->uuid_count;
BT_INFO("UUID Count [%d]", dev_info->uuid_count);
dev_info->trust = oal_device->is_trusted;
+ BT_INFO("iS Trusted [%d]", dev_info->trust);
if (dev_info->uuid_count > 0)
dev_info->uuids = g_new0(char *, dev_info->uuid_count);
[DPM_POLICY_BLUETOOTH_SPP_PROFILE_STATE] = {DPM_STATUS_ERROR},
};
-int _bt_launch_dpm_popup(char *mode)
+int _bt_launch_dpm_popup(const char *mode)
{
int ret = 0;
bundle *b;
+ char *str;
b = bundle_create();
retv_if(b == NULL, BLUETOOTH_ERROR_INTERNAL);
bundle_add(b, "mode", mode);
- ret = syspopup_launch(BT_DPM_SYSPOPUP, b);
+ str = g_strdup(BT_DPM_SYSPOPUP);
+ ret = syspopup_launch(str, b);
+ g_free(str);
if (ret < 0)
BT_ERR("Popup launch failed: %d\n", ret);
GVariant *uuids = NULL;
GVariantBuilder *builder = NULL;
GVariant *manufacturer_data;
- int i = 0;
+ unsigned int i = 0;
BT_INFO("Send Service Search request event");
builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
- for (i=0; i < remote_dev_info->uuid_count; i++) {
+ for (i = 0; i < remote_dev_info->uuid_count; i++) {
g_variant_builder_add(builder, "s",
remote_dev_info->uuids[i]);
}
static void __bt_device_services_callback(event_dev_services_t* uuid_list)
{
bt_remote_dev_info_t *rem_info = NULL;
- int i;
+ unsigned int i;
BT_DBG("+");
if (trigger_bond_info && _bt_compare_adddress(trigger_bond_info->dev_addr,
rem_info->uuids = g_new0(char *, rem_info->uuid_count);
/* Fill Remote Device Service List list */
- for (i=0; i < rem_info->uuid_count; i++) {
+ for (i = 0; i < rem_info->uuid_count; i++) {
rem_info->uuids[i] = g_malloc0(BLUETOOTH_UUID_STRING_MAX);
_bt_uuid_to_string((service_uuid_t *)&uuid_list->service_list[i].uuid, rem_info->uuids[i]);
BT_DBG("UUID value=%s", rem_info->uuids[i]);
GVariant *uuids = NULL;
GVariantBuilder *builder = NULL;
GVariant *manufacturer_data;
- int i = 0;
+ unsigned int i = 0;
+
builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
- for (i=0; i < remote_dev_info->uuid_count; i++) {
+ for (i = 0; i < remote_dev_info->uuid_count; i++) {
g_variant_builder_add(builder, "s",
remote_dev_info->uuids[i]);
}
__bt_device_handle_pending_requests(result, BT_BOND_DEVICE,
trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
__bt_free_bond_info(BT_DEVICE_BOND_INFO);
- __bt_free_pairing_info(&trigger_pairing_info);
}
+
+ __bt_free_pairing_info(&trigger_pairing_info);
break;
}
case OAL_STATUS_INTERNAL_ERROR:
BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
param);
__bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
- __bt_free_pairing_info(&trigger_pairing_info);
} else if (trigger_bond_info) {
if (__bt_device_handle_bond_state()!= BLUETOOTH_ERROR_NONE) {
if (trigger_bond_info) {
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
__bt_free_bond_info(BT_DEVICE_BOND_INFO);
- __bt_free_pairing_info(&trigger_pairing_info);
}
}
}
+
+ __bt_free_pairing_info(&trigger_pairing_info);
break;
}
default:
BT_DBG("Name %s", dev_info->name);
GVariant *uuids = NULL;
GVariantBuilder *builder = NULL;
- int i = 0;
+ unsigned int i = 0;
+
builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
- for (i=0; i < dev_info->uuid_count; i++) {
+ for (i = 0; i < dev_info->uuid_count; i++) {
g_variant_builder_add(builder, "s",
dev_info->uuids[i]);
}
if (!conn_data)
break;
- if (*((int *)req_info->user_data) != conn_data->channel_id)
+ if (*((int *)req_info->user_data) != (int)conn_data->channel_id)
break;
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
case BT_HDP_DISCONNECT: {
bt_hdp_disconnected_t *disconn_data = data;
- if (*((int *)req_info->user_data) != disconn_data->channel_id)
+ if (*((int *)req_info->user_data) != (int)disconn_data->channel_id)
break;
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
bt_hdp_conn_info_t *info = data;
bt_hdp_connected_t *conn_data = info->data;
- if (*((int *)req_info->user_data) != conn_data->channel_id)
+ if (*((int *)req_info->user_data) != (int)conn_data->channel_id)
break;
BT_DBG("fd: %d", info->fd);
g_free(info->data);
g_free(info);
} else {
- bt_hdp_conn_info_t info;
-
- __bt_hdp_handle_pending_request_info(BLUETOOTH_ERROR_INTERNAL,
- BT_HDP_GET_FD, (void *)&info, sizeof(bt_hdp_conn_info_t));
+ __bt_hdp_handle_pending_request_info(
+ BLUETOOTH_ERROR_INTERNAL, BT_HDP_GET_FD, NULL, 0);
}
BT_DBG("-");
continue;
conn_info = (bt_hdp_connected_t *)(info->data);
- if (conn_info && (conn_info->channel_id == channel_id)) {
+ if (conn_info && ((int)conn_info->channel_id == channel_id)) {
BT_DBG("Match found");
break;
}
#include <dlog.h>
#include <string.h>
-#include "bluetooth-api.h"
#include "bt-internal-types.h"
#include "bt-request-handler.h"
#include "bt-service-util.h"
#include "bt-service-event.h"
+#include "bt-service-event-receiver.h"
#include "bt-service-common.h"
#include "bt-service-hidhost.h"
-#include "bt-service-event-receiver.h"
#include "oal-event.h"
#include "oal-device-mgr.h"
#include "oal-hid-host.h"
int _bt_adapter_get_bonded_devices(void);
+int _bt_init_profiles();
+
+int _bt_cleanup_profiles(void);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
#define _BT_SERVICE_CORE_DEVICE_H_
#include <sys/types.h>
+#include "bluetooth-api.h"
#ifdef __cplusplus
extern "C" {
};
typedef struct dpm_profile_val dpm_profile_state_t;
-int _bt_launch_dpm_popup(char *mode);
+int _bt_launch_dpm_popup(const char *mode);
dpm_result_t _bt_dpm_set_allow_bluetooth_mode(dpm_bt_allow_t value);
dpm_bt_allow_t _bt_dpm_get_allow_bluetooth_mode(void);
dpm_result_t _bt_dpm_activate_bluetooth_device_restriction(dpm_status_t value);
int bluetooth_hf_terminate_call();
-int bluetooth_hf_initiate_call(char *number);
+int bluetooth_hf_initiate_call(const char *number);
int bluetooth_hf_voice_recognition(unsigned int status);
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff