Taesoo Jun <steve.jun@samsung.com>
DoHyun Pyun <dh79.pyun@samsung.com>
Anupam Roy <anupam.r@samsung.com>
+Atul Rai <a.rai@samsung.com>
ADD_SUBDIRECTORY(bt-api)
-IF("$ENV{CFLAGS}" MATCHES "-DEMUL")
+IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_TEST_EMUL")
ADD_SUBDIRECTORY(bt-service-emul)
ELSE()
IF("$ENV{BT_INCLUDE_OAL}" STREQUAL "ENABLED")
bt-hid-device.c
bt-gatt-client.c
bt-ipsp.c
-bt-dpm.c)
+bt-dpm.c
+bt-proximity.c)
SET(HEADERS
bluetooth-api.h
#include "bt-event-handler.h"
static gboolean is_le_scanning = FALSE;
+static int is_scan_filter_supported = -1;
BT_EXPORT_API int bluetooth_check_adapter_le(void)
{
ret = _bt_get_adapter_path(_bt_gdbus_get_system_gconn(), NULL);
- if (ret != BLUETOOTH_ERROR_NONE) {
+ if (ret != BLUETOOTH_ERROR_NONE)
return BLUETOOTH_ADAPTER_LE_DISABLED;
- }
ret = vconf_get_int(VCONFKEY_BT_LE_STATUS, &value);
if (ret != 0) {
{
int result;
- retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_ENABLED,
- BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
-
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return is_discovering;
}
+BT_EXPORT_API gboolean bluetooth_is_scan_filter_supported(void)
+{
+ int result;
+
+ if (is_scan_filter_supported == -1) {
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SCAN_FILTER_SUPPORTED,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE)
+ is_scan_filter_supported = g_array_index(out_param, int, 0);
+ else
+ BT_ERR("Fail to send request");
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ }
+
+ if (is_scan_filter_supported == 1)
+ return TRUE;
+
+ return FALSE;
+}
+
BT_EXPORT_API int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id)
{
int result;
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REGISTER_SCAN_FILTER,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*slot_id = g_array_index(out_param, int, 0);
- } else {
+ else
BT_ERR("Fail to send request");
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
gboolean __bluetooth_is_privileged_process(void)
{
FILE *fp = NULL;
BT_CHECK_ENABLED_ANY(return);
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
use_reserved_slot = __bluetooth_is_privileged_process();
#endif
BT_CHECK_ENABLED_ANY(return);
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
use_reserved_slot = __bluetooth_is_privileged_process();
#endif
if (length > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 3)
return BLUETOOTH_ERROR_INVALID_PARAM;
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
use_reserved_slot = __bluetooth_is_privileged_process();
#endif
if (length > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX)
return BLUETOOTH_ERROR_INVALID_PARAM;
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
use_reserved_slot = __bluetooth_is_privileged_process();
#endif
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*is_advertising = g_array_index(out_param, int, 0);
- } else {
+ else
BT_ERR("Fail to send request");
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
+BT_EXPORT_API int bluetooth_set_le_static_random_address(gboolean enable)
+{
+ int result;
+
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, &enable, sizeof(gboolean));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_STATIC_RANDOM_ADDRESS,
+ 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_check_privilege_advertising_parameter(void)
{
if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SET_ADVERTISING_PARAMETERS)
BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result != BLUETOOTH_ERROR_NONE) {
+ if (result != BLUETOOTH_ERROR_NONE)
BT_ERR("Failed to Write the host suggested default data length values : %d", result);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_LE_SET_DATA_LENGTH,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result != BLUETOOTH_ERROR_NONE) {
+ if (result != BLUETOOTH_ERROR_NONE)
BT_ERR("Failed to Set data length values : %d", result);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
dev_info = g_memdup(&info, sizeof(bluetooth_device_info_t));
- if (dev_info) {
+ if (dev_info)
g_ptr_array_add(*dev_list, (gpointer)dev_info);
- }
}
return BLUETOOTH_ERROR_NONE;
BT_EXPORT_API int bluetooth_check_adapter(void)
{
- int value;
+ int value = VCONFKEY_BT_STATUS_OFF;
-#ifndef EMUL
+#ifndef TIZEN_TEST_EMUL
int ret;
ret = _bt_get_adapter_path(_bt_gdbus_get_system_gconn(), NULL);
- if (ret != BLUETOOTH_ERROR_NONE) {
+ if (ret != BLUETOOTH_ERROR_NONE)
return BLUETOOTH_ADAPTER_DISABLED;
- }
#endif
/* check VCONFKEY_BT_STATUS */
BT_EXPORT_API int bluetooth_enable_adapter(void)
{
int result;
- bt_user_info_t *user_info;
- BT_INFO("");
+ BT_INFO_C("### Enable adapter");
retv_if(bluetooth_check_adapter() == BLUETOOTH_ADAPTER_ENABLED,
BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
BLUETOOTH_ERROR_PERMISSION_DEINED);
#endif
- user_info = _bt_get_user_data(BT_COMMON);
- 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);
- result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER,
- in_param1, in_param2, in_param3, in_param4,
- user_info->cb, user_info->user_data);
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_EXPORT_API int bluetooth_disable_adapter(void)
{
int result;
- bt_user_info_t *user_info;
- BT_INFO("");
+ BT_INFO_C("### Disable adapter");
BT_CHECK_ENABLED(return);
- user_info = _bt_get_user_data(BT_COMMON);
- 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);
- result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER,
- in_param1, in_param2, in_param3, in_param4,
- user_info->cb, user_info->user_data);
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
{
int result;
- BT_INFO("");
+ BT_INFO("Recover adapter");
BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_LOCAL_VERSION,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*local_version = g_array_index(out_param, bluetooth_version_t, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_SERVICE_USED,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*used = g_array_index(out_param, gboolean, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(discoverable_mode_ptr, return);
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
int timeout = 0;
/* Requirement in OSP */
if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_DISABLED) {
return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
}
- if (timeout == -1) {
+ if (timeout == -1)
*discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
- } else {
+ else
*discoverable_mode_ptr = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
- }
return BLUETOOTH_ERROR_NONE;
}
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_MODE,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*discoverable_mode_ptr = g_array_index(out_param, int, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DISCOVERABLE_TIME,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*timeout = g_array_index(out_param, int, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
int, 0);
} else {
BT_ERR("Fail to send request");
+ is_discovering = result;
}
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_CONNECTABLE,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*is_connectable = g_array_index(out_param, int, 0);
- } else {
+ else
BT_ERR("Fail to send request");
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
+BT_EXPORT_API int bluetooth_get_profile_connected_device_list(
+ const char *profile_uuid, GPtrArray **addr_list)
+{
+ char uuid[BLUETOOTH_UUID_STRING_MAX];
+ int result;
+ guint size;
+ int i;
+
+ BT_CHECK_PARAMETER(profile_uuid, return);
+ BT_CHECK_PARAMETER(addr_list, return);
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_strlcpy(uuid, profile_uuid, sizeof(uuid));
+ g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_CONNECTED_DEVICES,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ if (out_param == NULL) {
+ BT_ERR("out_param is NULL");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ size = (out_param->len) / sizeof(bluetooth_device_address_t);
+
+ if (size == 0) {
+ BT_ERR("No connected device");
+ result = BLUETOOTH_ERROR_NOT_CONNECTED;
+ }
+
+ for (i = 0; i < size; i++) {
+ bluetooth_device_address_t *addr = NULL;
+ bluetooth_device_address_t *ptr = NULL;
+
+ ptr = &g_array_index(out_param,
+ bluetooth_device_address_t, i);
+
+ addr = g_memdup(ptr, sizeof(bluetooth_device_address_t));
+
+ if (addr)
+ g_ptr_array_add(*addr_list, (gpointer)addr);
+ }
+ }
+ }
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
BT_EXPORT_API int bluetooth_set_manufacturer_data(const bluetooth_manufacturer_data_t *value)
{
int result;
return result;
}
+
+BT_EXPORT_API int bluetooth_set_passkey_notification(gboolean enable)
+{
+ int result;
+
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, &enable, sizeof(gboolean));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PASSKEY_NOTIFICATION,
+ 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;
+}
#include "bt-dpm.h"
#endif
-
BT_EXPORT_API int bluetooth_audio_init(bt_audio_func_ptr cb, void *user_data)
{
int ret;
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);
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;
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);
BT_CHECK_ENABLED(return);
- strncpy(buffer, "AT+XSAT=", strlen("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);
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");
- }
g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
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;
+}
#include "bt-dpm.h"
#endif
-
BT_EXPORT_API int bluetooth_media_player_init(media_cb_func_ptr callback_ptr,
void *user_data)
{
return result;
}
+BT_EXPORT_API int bluetooth_media_target_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_AVRCP_TARGET_CONNECT)
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have a privilege to use this API");
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ }
+
+#ifdef TIZEN_DPM_ENABLE
+ if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
+ BT_ERR("Not allow to use AVRCP profile");
+ return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
+ }
+#endif
+ user_info = _bt_get_user_data(BT_AVRCP);
+ 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));
+
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE,
+ BT_AVRCP_TARGET_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_media_target_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_AVRCP_TARGET_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_AVRCP);
+ 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));
+
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE,
+ BT_AVRCP_TARGET_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_media_control_command(
media_player_control_cmd type)
{
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
#endif
-
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
static GDBusConnection *system_gconn = NULL;
+static gboolean bt_enabled = FALSE;
+
#define DBUS_TIMEOUT 20 * 1000 /* 20 Seconds */
GDBusConnection *g_bus_get_private_conn(void)
GDBusConnection *_bt_gdbus_get_system_gconn(void)
{
-
-
- if (system_gconn == NULL) {
+ if (system_gconn == NULL)
system_gconn = _bt_gdbus_init_system_gconn();
- } else if (g_dbus_connection_is_closed(system_gconn)) {
+ else if (g_dbus_connection_is_closed(system_gconn))
system_gconn = g_bus_get_private_conn();
- }
return system_gconn;
}
void _bt_convert_addr_string_to_type(unsigned char *addr,
const char *address)
{
- int i;
- char *ptr = NULL;
+ int i;
+ char *ptr = NULL;
ret_if(address == NULL);
ret_if(addr == NULL);
- for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
- addr[i] = strtol(address, &ptr, 16);
- if (ptr[0] != '\0') {
- if (ptr[0] != ':')
- return;
+ for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
+ addr[i] = strtol(address, &ptr, 16);
+ if (ptr[0] != '\0') {
+ if (ptr[0] != ':')
+ return;
- address = ptr + 1;
- }
- }
+ address = ptr + 1;
+ }
+ }
+}
+
+void _bt_convert_addr_string_to_secure_string(char *addr,
+ const char *address)
+{
+ int len;
+
+ ret_if(address == NULL);
+ ret_if(addr == NULL);
+
+ len = strlen(address);
+ ret_if(len != BT_ADDRESS_STRING_SIZE - 1);
+
+ strncpy(addr, address, len);
+
+ addr[len-1] = 'X';
+ addr[len-2] = 'X';
+
+ return;
}
void _bt_convert_addr_type_to_string(char *address,
char addr[20];
bluetooth_device_address_t remote_addr1;
bt_new_connection_cb cb = user_data;
+ char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
int fd;
g_variant_get(parameters, "(oha{sv})", &obj_path, &index,
g_error_free(err);
return;
}
- BT_INFO("Object Path %s", obj_path);
- _bt_device_path_to_address(obj_path, addr);
+ _bt_convert_device_path_to_address(obj_path, addr);
_bt_convert_addr_string_to_type(remote_addr1.addr, (const char *)addr);
- BT_INFO("fd: %d, address %s", fd, addr);
+
+ _bt_convert_addr_string_to_secure_string(secure_address, addr);
+ BT_INFO("fd: %d, address %s", fd, secure_address);
g_dbus_method_invocation_return_value(invocation, NULL);
}
if (ret)
g_variant_unref(ret);
-
g_object_unref(adapter_proxy);
-
object_path = _bt_get_device_object_path(address);
if (object_path == NULL)
return BLUETOOTH_ERROR_INTERNAL;
char *object_path;
GDBusProxy *proxy;
GDBusProxy *adapter_proxy;
+ GVariant *ret = NULL;
GError *err = NULL;
object_path = _bt_get_device_object_path(address);
if (object_path == NULL) {
}
if (ret)
g_variant_unref(ret);
-
g_object_unref(adapter_proxy);
-
object_path = _bt_get_device_object_path(address);
if (object_path == NULL)
return BLUETOOTH_ERROR_INTERNAL;
}
proxy = __bt_gdbus_get_device_proxy(object_path);
g_free(object_path);
- g_dbus_proxy_call_sync(proxy, "CancelDiscovery",
+ ret = g_dbus_proxy_call_sync(proxy, "CancelDiscovery",
NULL,
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL,
g_clear_error(&err);
return BLUETOOTH_ERROR_INTERNAL;
}
+ if (ret)
+ g_variant_unref(ret);
if (proxy)
g_object_unref(proxy);
return BLUETOOTH_ERROR_NONE;
result = g_dbus_proxy_call_sync(manager_proxy, "DefaultAdapter", NULL,
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
if (!result) {
- if (err != NULL)
- BT_ERR("Fail to get DefaultAdapter (Error: %s)", err->message);
- else
+ if (err != NULL) {
+ if (!g_strrstr(err->message, "ServiceUnknown"))
+ BT_ERR("Fail to get DefaultAdapter (Error: %s)", err->message);
+ } else {
BT_ERR("Fail to get DefaultAdapter");
+ }
goto fail;
}
dev_addr += 4;
g_strlcpy(address, dev_addr, sizeof(address));
- while ((pos = strchr(address, '_')) != NULL) {
+ while ((pos = strchr(address, '_')) != NULL)
*pos = ':';
- }
g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
}
retv_if(object_path == NULL, NULL);
_bt_convert_device_path_to_address(object_path, device_address);
- if (g_strcmp0(address, device_address) == 0) {
+ if (g_strcmp0(address, device_address) == 0)
return g_strdup(object_path);
- }
}
return NULL;
}
return object_path;
}
-void _bt_device_path_to_address(const char *device_path, char *device_address)
-{
- char address[BT_ADDRESS_STRING_SIZE] = { 0 };
- char *dev_addr = NULL;
-
- if (!device_path || !device_address)
- return;
-
- dev_addr = strstr(device_path, "dev_");
- if (dev_addr != NULL) {
- char *pos = NULL;
- dev_addr += 4;
- g_strlcpy(address, dev_addr, sizeof(address));
-
- while ((pos = strchr(address, '_')) != NULL) {
- *pos = ':';
- }
-
- g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
- }
-}
-
GDBusConnection *_bt_init_system_gdbus_conn(void)
{
GError *error = NULL;
{
int result;
+ BT_CHECK_ENABLED(return);
+
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
+gboolean _bt_check_enabled_internal(void)
+{
+ if (bt_enabled == TRUE)
+ return TRUE;
+
+ if (bluetooth_check_adapter() == BLUETOOTH_ADAPTER_ENABLED)
+ bt_enabled = TRUE;
+
+ return bt_enabled;
+}
+
+void _bt_set_adapter_internal_status(gboolean enabled)
+{
+ bt_enabled = enabled;
+}
+
+int _bt_get_uuid_specification_name(const char *uuid, char **name)
+{
+ int i;
+ int offset = 0;
+ int uuid_len = 4;
+ static struct {
+ const char *uuid;
+ const char *specification_name;
+ } bt_uuid_name[] = {
+ /* GATT Services */
+ {"1800", "Generic Access"},
+ {"1801", "Generic Attribute"},
+ {"1802", "Immediate Alert"},
+ {"1803", "Link Loss"},
+ {"1804", "Tx Power"},
+ {"1805", "Current Time Service"},
+ {"1806", "Reference Time Update Service"},
+ {"1807", "Next DST Change Service"},
+ {"1808", "Glucose"},
+ {"1809", "Health Thermometer"},
+ {"180A", "Device Information"},
+ {"180D", "Heart Rate"},
+ {"180F", "Battery Service"},
+ {"1810", "Blood Pressure"},
+ {"1811", "Alert Notification Service"},
+ {"1812", "Human Interface Device"},
+
+ /* GATT Declarations */
+ {"2800", "Primary Service Declaration"},
+ {"2801", "Secondary Service Declaration"},
+ {"2802", "Include Declaration"},
+ {"2803", "Characteristic Declaration"},
+
+ /* GATT Descriptors */
+ {"2900", "Characteristic Extended Properties"},
+ {"2901", "Characteristic User Description"},
+ {"2902", "Client Characteristic Configuration"},
+ {"2903", "Server Characteristic Configuration"},
+ {"2904", "Characteristic Format"},
+ {"2905", "Characteristic Aggregate Formate"},
+ {"2906", "Valid Range"},
+ {"2907", "External Report Reference"},
+ {"2908", "Report Reference"},
+
+ /* GATT Characteristics */
+ {"2A00", "Device Name"},
+ {"2A01", "Appearance"},
+ {"2A02", "Peripheral Privacy Flag"},
+ {"2A03", "Reconnection Address"},
+ {"2A04", "Peripheral Preferred Connection Parameters"},
+ {"2A05", "Service Changed"},
+ {"2A06", "Alert Level"},
+ {"2A07", "Tx Power Level"},
+ {"2A08", "Date Time"},
+ {"2A09", "Day of Week"},
+ {"2A0A", "Day Date Time"},
+ {"2A19", "Battery Level"},
+ {"2A1E", "Intermediate Temperature"},
+ {"2A23", "System ID"},
+ {"2A24", "Model Number String"},
+ {"2A25", "Serial Number String"},
+ {"2A26", "Firmware Revision String"},
+ {"2A27", "Hardware Revision String"},
+ {"2A28", "Software Revision String"},
+ {"2A29", "Manufacturer Name String"},
+ {"2A2A", "IEEE 11073-20601 Regulatory Certification Data List"},
+ {"2A2B", "Current Time"},
+ {"2A37", "Heart Rate Measurement"},
+ {"2A38", "Body Sensor Location"},
+ {"2A3F", "Alert Status"},
+ {"2A46", "New Alert"},
+ {"2A4A", "HID Information"},
+ {"2A4C", "HID Control Point"},
+ {"2A50", "PnP ID"},
+
+ /* Custom uuids */
+ {"7905F431-B5CE-4E99-A40F-4B1E122D00D0", "Apple Notification Center Service"},
+ {"9FBF120D-6301-42D9-8C58-25E699A21DBD", "Notifications Source"},
+ {"69D1D8F3-45E1-49A8-9821-9BBDFDAAD9D9", "Control Point"},
+ {"22EAC6E9-24D6-4BB5-BE44-B36ACE7C7BFB", "Data Source"},
+ {"89D3502B-0F36-433A-8EF4-C502AD55F8DC", "Apple Media Service"},
+ {"9B3C81D8-57B1-4A8A-B8DF-0E56F7CA51C2", "Remote Command"},
+ {"2F7CABCE-808D-411F-9A0C-BB92BA96C102", "Entity Update"},
+ {"C6B2F38C-23AB-46D8-A6AB-A3A870BBD5D7", "Entity Attribute"},
+ {"9A3F68E0-86CE-11E5-A309-0002A5D5C51B", "Samsung Gear Manager Service"},
+ {"c2f2cc0f-c085-4dd4-be5a-aca3074bbc72", "Control Point"},
+ {"cece518b-28d7-4171-92d5-76a1e249a3b9", "Notifications Source"},
+ {NULL, NULL}
+ };
+
+ if (!uuid || !name)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+ if (strlen(uuid) == 36) {
+ if (!g_ascii_strncasecmp(uuid + 9, "0000-1000-8000-00805F9B34FB", 27))
+ offset = 4;
+ else {
+ offset = 0;
+ uuid_len = 36;
+ }
+ } else if (strlen(uuid) >= 8)
+ offset = 4;
+
+ for (i = 0; bt_uuid_name[i].uuid; i++) {
+ if (!g_ascii_strncasecmp(uuid + offset, bt_uuid_name[i].uuid, uuid_len)) {
+ *name = g_strdup(bt_uuid_name[i].specification_name);
+ return BLUETOOTH_ERROR_NONE;
+ }
+ }
+
+ *name = g_strdup("Unknown");
+ return BLUETOOTH_ERROR_NONE;
+}
+
BT_EXPORT_API int bluetooth_is_supported(void)
{
int is_supported = 0;
_bt_set_user_data(BT_COMMON, (void *)callback_ptr, user_data);
/* Register All events */
- ret = _bt_register_event(BT_ADAPTER_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
- ret = _bt_register_event(BT_DEVICE_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
- ret = _bt_register_event(BT_NETWORK_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
- ret = _bt_register_event(BT_RFCOMM_CLIENT_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
- ret = _bt_register_event(BT_RFCOMM_SERVER_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
+ if (ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
+ ret = _bt_register_event(BT_ADAPTER_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
+ ret = _bt_register_event(BT_DEVICE_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
+ ret = _bt_register_event(BT_NETWORK_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
+ ret = _bt_register_event(BT_RFCOMM_CLIENT_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
+ ret = _bt_register_event(BT_RFCOMM_SERVER_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
+
#ifdef GATT_NO_RELAY
- ret = _bt_register_event(BT_GATT_BLUEZ_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
+ ret = _bt_register_event(BT_GATT_BLUEZ_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
#endif
- ret = _bt_register_event(BT_HDP_EVENT, (void *)callback_ptr, user_data);
- if (ret != BLUETOOTH_ERROR_NONE)
- goto fail;
+ ret = _bt_register_event(BT_HDP_EVENT, (void *)callback_ptr, user_data);
+ if (ret != BLUETOOTH_ERROR_NONE)
+ goto fail;
+ }
_bt_register_name_owner_changed();
ret = _bt_deinit_event_handler();
- if (ret != BLUETOOTH_ERROR_NONE) {
+ if (ret != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to deinit the event handler");
- }
_bt_unregister_name_owner_changed();
bt_user_info_t *user_info;
BT_CHECK_PARAMETER(device_address, return);
- if (conn_type == BLUETOOTH_DEV_CONN_BREDR) {
- BT_CHECK_ENABLED(return);
- } else if (conn_type == BLUETOOTH_DEV_CONN_LE) {
- BT_CHECK_ENABLED_LE(return);
- } else if (conn_type == BLUETOOTH_DEV_CONN_DEFAULT) {
- BT_CHECK_ENABLED(return);
- BT_CHECK_ENABLED_LE(return);
- }
+ BT_CHECK_ENABLED(return);
if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_BOND_DEVICE_BY_TYPE)
== BLUETOOTH_ERROR_PERMISSION_DEINED) {
{
int result;
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
bt_user_info_t *user_info;
BT_CHECK_PARAMETER(device_address, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_UNBOND_DEVICE)
== BLUETOOTH_ERROR_PERMISSION_DEINED) {
BT_CHECK_PARAMETER(device_address, return);
BT_CHECK_PARAMETER(dev_info, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
+BT_EXPORT_API int bluetooth_get_is_alias_set(const bluetooth_device_address_t *device_address,
+ gboolean *is_alias_set)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_PARAMETER(is_alias_set, return);
+ 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, device_address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_IS_ALIAS_SET,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE)
+ *is_alias_set = g_array_index(out_param, gboolean, 0);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
BT_EXPORT_API int bluetooth_get_remote_device(const bluetooth_device_address_t *device_address)
{
return BLUETOOTH_ERROR_NONE;
bt_user_info_t *user_info;
BT_CHECK_PARAMETER(device_address, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SEARCH_SERVICE)
== BLUETOOTH_ERROR_PERMISSION_DEINED) {
{
int result;
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(device_address, return);
BT_CHECK_PARAMETER(alias, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
int result;
BT_CHECK_PARAMETER(device_address, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(device_address, return);
BT_CHECK_PARAMETER(is_connected, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
if (type & BLUETOOTH_RFCOMM_SERVICE) {
result = bluetooth_rfcomm_client_is_connected(device_address, is_connected);
- /* TODO: Enable below code once rfcomm server implementation is done */
-#if 0
if (*is_connected == FALSE)
result = bluetooth_rfcomm_server_is_connected(device_address, is_connected);
-#endif
+
return result;
}
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_DEVICE_CONNECTED,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*is_connected = g_array_index(out_param, gboolean, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
user_info = _bt_get_user_data(BT_COMMON);
retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
+ BT_INFO_C("### Connect LE");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_CONNECT_LE,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
BT_CHECK_PARAMETER(device_address, return);
BT_CHECK_ENABLED_ANY(return);
+ if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_DISCONNECT_LE)
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have a privilege to use this API");
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ }
+
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
-
user_info = _bt_get_user_data(BT_COMMON);
retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
+ BT_INFO_C("### Disconnect LE");
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_DISCONNECT_LE,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
BT_EXPORT_API int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
int link_type, bt_rssi_threshold_t *rssi_threshold)
{
+#ifdef __BROADCOM_PATCH__
int result;
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(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;
+#else
+ BT_ERR("Current chipset does not support this function.");
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+#endif
}
BT_EXPORT_API int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
{
+#ifdef __BROADCOM_PATCH__
int result;
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(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;
+#else
+ BT_ERR("Current chipset does not support this function.");
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+#endif
}
BT_EXPORT_API int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
{
int result;
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_CHECK_PARAMETER(address, return);
BT_CHECK_PARAMETER(parameters, return);
int result;
BT_CHECK_PARAMETER(device_address, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_CONNECTED_LINK_TYPE,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*connected = g_array_index(out_param, guint, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
+BT_EXPORT_API int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu)
+{
+ int result;
+ bt_user_info_t *user_info;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_ENABLED_ANY(return);
+
+ if (mtu > BLUETOOTH_MAX_ATT_MTU)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_REQ_ATT_MTU)
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have a privilege to use this API");
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ }
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &mtu, sizeof(unsigned int));
+
+ user_info = _bt_get_user_data(BT_COMMON);
+ retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_REQ_ATT_MTU,
+ 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_get_att_mtu(const bluetooth_device_address_t *device_address,
+ unsigned int *mtu)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_PARAMETER(mtu, return);
+ 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, device_address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ATT_MTU,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE)
+ *mtu = g_array_index(out_param, unsigned int, 0);
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
+ bluetooth_device_address_t *id_address)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_rpa, return);
+ BT_CHECK_PARAMETER(id_address, return);
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, device_rpa, sizeof(bluetooth_device_address_t));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_DEVICE_IDA,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ *id_address = g_array_index(out_param,
+ bluetooth_device_address_t, 0);
+ }
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_force_hcidump(int timeout)
+{
+ int result;
+
+ BT_CHECK_ENABLED_ANY(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ g_array_append_vals(in_param1, &timeout, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_FORCE_HCI_DUMP,
+ 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_set_profile_trusted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int trust)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ 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, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &profile, sizeof(int));
+ g_array_append_vals(in_param3, &trust, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_TRUSTED,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE)
+ BT_DBG("SUCCESSFUL");
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_get_profile_trusted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int *trust)
+{
+ int result;
+ int trust_profile = 0;
+ BT_CHECK_PARAMETER(device_address, return);
+ 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, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &profile, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_TRUSTED,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ trust_profile = g_array_index(out_param, guint, 0);
+ BT_DBG("SUCCESSFUL");
+ }
+ BT_DBG("TRUST %d", trust_profile);
+ *trust = trust_profile;
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_set_profile_restricted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int restricted)
+{
+ int result;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ 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, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &profile, sizeof(int));
+ g_array_append_vals(in_param3, &restricted, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_PROFILE_RESTRICTED,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE)
+ BT_DBG("SUCCESSFUL");
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_get_profile_restricted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int *restricted)
+{
+ int result;
+ int restrict_profile = 0;
+ BT_CHECK_PARAMETER(device_address, return);
+ 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, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &profile, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_PROFILE_RESTRICTED,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ restrict_profile = g_array_index(out_param, guint, 0);
+ BT_DBG("SUCCESSFUL");
+ }
+ BT_DBG("Restricted %d", restrict_profile);
+ *restricted = restrict_profile;
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
BT_EXPORT_API int bluetooth_passkey_reply(char *passkey, gboolean reply)
{
int result;
dpm_status = _bt_check_dpm_blacklist_uuid(BT_OPP_UUID);
- if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED) {
+ if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
return dpm_status;
- }
bluetooth_dpm_get_data_transfer_state(&dpm_value);
dpm_status = _bt_check_dpm_blacklist_uuid(BT_HFP_AUDIO_GATEWAY_UUID);
- if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED) {
+ if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
return dpm_status;
- }
dpm_status = _bt_check_dpm_blacklist_uuid(BT_HSP_AUDIO_GATEWAY_UUID);
- if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED) {
+ if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
return dpm_status;
- }
+
return dpm_status;
}
dpm_status = _bt_check_dpm_blacklist_uuid(BT_A2DP_UUID);
- if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED) {
+ if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
return dpm_status;
- }
return dpm_status;
}
dpm_status = _bt_check_dpm_blacklist_uuid(BT_AVRCP_TARGET_UUID);
- if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED) {
+ if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
return dpm_status;
- }
return dpm_status;
}
dpm_status = _bt_check_dpm_blacklist_uuid(BT_SPP_UUID);
- if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED) {
+ if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
return dpm_status;
- }
return dpm_status;
}
#endif
#ifdef TIZEN_DPM_VCONF_ENABLE
- if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
BT_ERR("Error in reading VCONFKEY_BT_STATUS");
- }
if (bt_status == VCONFKEY_BT_STATUS_ON) {
if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
BT_ERR("Set VCONFKEY_BT_DPM_STATUS failed\n");
result = BLUETOOTH_DPM_RESULT_FAIL;
- } else
+ } else {
+ BT_ERR("Set VCONFKEY_BT_DPM_STATUS success\n");
result = BLUETOOTH_DPM_RESULT_SUCCESS;
+ }
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
for (i = 0; i < count; i++) {
memset(dst_info->addresses[i].addr, 0,
- BT_ADDRESS_STRING_SIZE);
+ BLUETOOTH_ADDRESS_LENGTH);
g_strlcpy((gchar *)dst_info->addresses[i].addr, (gchar *)src_info->addresses[i].addr,
- BT_ADDRESS_STRING_SIZE);
+ BLUETOOTH_ADDRESS_LENGTH);
// BT_DBG("address[%d] : %s", i, dst_info->addresses[i].addr);
}
#include "bluetooth-api.h"
#include "bluetooth-audio-api.h"
+#include "bluetooth-hid-api.h"
#include "bt-internal-types.h"
#include "bluetooth-media-control.h"
#include "bt-common.h"
#include "bt-event-handler.h"
+#include "bt-gatt-client.h"
#include "bt-request-sender.h"
+#define PROFILE_SUPPORTED 0x3 /* This corresponds to binary 0b11*/
#define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
typedef struct {
static GSList *server_list = NULL;
static GSList *event_list = NULL;
static int owner_sig_id = -1;
-static gboolean is_adapter_enabled = TRUE;
void _bt_add_push_request_id(int request_id)
{
return le_dev_info;
}
+static bluetooth_ibeacon_device_info_t *__bt_get_ibeacon_device_info_in_message(GVariant *parameters, int *ret)
+{
+ bluetooth_ibeacon_device_info_t *ibeacon_dev_info = NULL;
+ const char *address = NULL;
+ short addr_type = 0;
+ int company_id = 0;
+ int ibeacon_type = 0;
+ int major_id = 0;
+ int minor_id = 0;
+ int measured_power = 0;
+ const char *uuid = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+
+ g_variant_get(parameters, "(i&snnn&snnn)", &result, &address,
+ &addr_type, &company_id, &ibeacon_type, &uuid, &major_id, &minor_id, &measured_power);
+ ibeacon_dev_info = g_malloc0(sizeof(bluetooth_ibeacon_device_info_t));
+ if (ibeacon_dev_info == NULL) {
+ result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+ goto done;
+ }
+
+ _bt_convert_addr_string_to_type(ibeacon_dev_info->device_address.addr, address);
+ ibeacon_dev_info->addr_type = addr_type;
+ ibeacon_dev_info->company_id = company_id;
+ ibeacon_dev_info->ibeacon_type = ibeacon_type;
+ ibeacon_dev_info->major_id = major_id;
+ ibeacon_dev_info->minor_id = minor_id;
+ ibeacon_dev_info->measured_power = measured_power;
+ ibeacon_dev_info->uuid_len = strlen(uuid);
+ memcpy(ibeacon_dev_info->uuid, uuid, ibeacon_dev_info->uuid_len);
+done:
+
+ *ret = result;
+
+ return ibeacon_dev_info;
+}
+
gboolean __bt_reliable_disable_cb(gpointer user_data)
{
BT_DBG("+");
_bt_set_le_scan_status(FALSE);
+ _bt_set_adapter_internal_status(FALSE);
+
if (is_initialized != FALSE) {
- if (is_adapter_enabled == TRUE) {
- is_adapter_enabled = FALSE;
- _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
- BLUETOOTH_ERROR_NONE, NULL,
- event_info->cb, event_info->user_data);
- _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
- BLUETOOTH_ERROR_NONE, NULL,
- event_info->cb, event_info->user_data);
- }
+ _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
+ BLUETOOTH_ERROR_NONE, NULL,
+ event_info->cb, event_info->user_data);
}
obex_server_id = BT_NO_SERVER;
#ifdef RFCOMM_DIRECT
_bt_rfcomm_server_free_all();
#endif
+
+ _bluetooth_hid_free_hid_info();
+
BT_DBG("-");
return FALSE;
}
if (strcasecmp(signal_name, BT_ENABLED) == 0) {
BT_INFO("BT_ENABLED");
g_variant_get(parameters, "(i)", &result);
- if (result == BLUETOOTH_ERROR_NONE) {
- if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
- BT_ERR("Set vconf failed");
-
- if (vconf_set_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, 0) != 0)
- BT_ERR("Set vconf failed");
-
- if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 0) != 0)
- BT_ERR("Set vconf failed");
- }
-
- is_adapter_enabled = TRUE;
_bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
result, NULL,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
BT_INFO("BT_DISABLED");
- int flight_mode_value = 0;
- int ps_mode_value = 0;
-
- if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE,
- &flight_mode_value) != 0)
- BT_ERR("Fail to get the flight_mode_deactivated value");
- if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE,
- &ps_mode_value) != 0)
- BT_ERR("Fail to get the ps_mode_deactivated value");
-
- if (flight_mode_value == 1 || ps_mode_value > 0) {
- BT_INFO("Flight mode deactivation");
- if (disable_timer_id > 0)
- g_source_remove(disable_timer_id);
-
- disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
- (GSourceFunc)__bt_reliable_disable_cb,
- event_info);
- } else {
- is_adapter_enabled = FALSE;
-
- _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
- result, NULL,
- event_info->cb, event_info->user_data);
- }
+ /* Wait for the termining time of bt-service */
+ if (disable_timer_id > 0)
+ g_source_remove(disable_timer_id);
- _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
- result, NULL,
- event_info->cb, event_info->user_data);
+ disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
+ (GSourceFunc)__bt_reliable_disable_cb,
+ event_info);
} else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
int mode = 0;
event_info->cb, event_info->user_data);
g_variant_unref(var);
+ } else if (strcasecmp(signal_name, BT_PASSKEY_NOTIFICATION) == 0) {
+ const char *address = NULL;
+ const char *passkey = NULL;
+ const char *passkey_info[2];
+
+ g_variant_get(parameters, "(&s&s)", &address, &passkey);
+ passkey_info[0] = address;
+ passkey_info[1] = passkey;
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_NOTIFICATION,
+ BLUETOOTH_ERROR_NONE, (void*)passkey_info,
+ event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
int event;
bluetooth_device_info_t *device_info;
&result);
ret_if(le_device_info == NULL);
- _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
+ if (bluetooth_is_le_scanning() == TRUE) {
+ _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
result, le_device_info,
event_info->cb, event_info->user_data);
+ }
g_free(le_device_info);
+ } else if (strcasecmp(signal_name, BT_IBEACON_DEVICE_FOUND) == 0) {
+ bluetooth_ibeacon_device_info_t *ibeacon_device_info;
+ BT_DBG("BT_IBEACON_DEVICE_FOUND");
+ ibeacon_device_info = __bt_get_ibeacon_device_info_in_message(parameters,
+ &result);
+ ret_if(ibeacon_device_info == NULL);
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_IBEACON_DEVICE_FOUND,
+ result, ibeacon_device_info,
+ event_info->cb, event_info->user_data);
+
+ g_free(ibeacon_device_info);
}
}
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
result, &dev_address,
event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
+ const char *address = NULL;
+ bluetooth_device_address_t dev_address = { {0} };
+ bluetooth_le_att_mtu_info_t att_mtu_info;
+ guint16 mtu;
+ guint8 status;
+ BT_DBG("BT_GATT_REQ_ATT_MTU_CHANGED");
+ g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
+
+ _bt_convert_addr_string_to_type(dev_address.addr, address);
+
+ memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
+ memcpy(att_mtu_info.device_address.addr,
+ dev_address.addr,
+ BLUETOOTH_ADDRESS_LENGTH);
+
+ att_mtu_info.mtu = mtu;
+ att_mtu_info.status = status;
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
+ result, &att_mtu_info,
+ event_info->cb, event_info->user_data);
#ifdef GATT_NO_RELAY
} else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
#else
g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
len = g_variant_get_size(char_value_var);
+ ret_if(char_value_var == NULL);
+
if (len > 0)
value = (char *)g_variant_get_data(char_value_var);
if (char_val.char_value == NULL) {
BT_ERR("BLUETOOTH_ERROR_OUT_OF_MEMORY");
g_free(char_val.char_handle);
- if (char_value_var)
- g_variant_unref(char_value_var);
+ g_variant_unref(char_value_var);
return;
}
memcpy(char_val.char_value, value, len);
result, &char_val,
event_info->cb, event_info->user_data);
g_free(char_val.char_value);
- if (char_value_var)
- g_variant_unref(char_value_var);
+ g_variant_unref(char_value_var);
}
g_free(char_val.char_handle);
} else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
_bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
result, &dev_address,
event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, BT_SUPPORTED_PROFILE_TRUSTED) == 0) {
+ char *address;
+ bt_supported_profile_trusted_t profile_info = { 0, };
+ int trust;
+
+ g_variant_get(parameters, "(i&si)", &result,
+ &address, &trust);
+
+ BT_DBG("Address [%s] trust[%d]", address, trust);
+ profile_info.address = address;
+ if (trust & (PROFILE_SUPPORTED << 0)) { /* Bit 0 & 1 - for PBAP Supported */
+ profile_info.profile = TRUSTED_PROFILE_PBAP;
+ profile_info.supported = TRUE;
+ if (trust & (1 << 1)) /* Bit 1 - for PBAP Trusted */
+ profile_info.trusted = TRUE;
+ else
+ profile_info.trusted = FALSE;
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
+ result, &profile_info,
+ event_info->cb, event_info->user_data);
+ }
+ if (trust & (PROFILE_SUPPORTED << 2)) { /* Bit 2 & 3 - for MAP Supported */
+ profile_info.profile = TRUSTED_PROFILE_MAP;
+ profile_info.supported = TRUE;
+ if (trust & (1 << 3)) /* Bit 3 - for PBAP Trusted */
+ profile_info.trusted = TRUE;
+ else
+ profile_info.trusted = FALSE;
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
+ result, &profile_info,
+ event_info->cb, event_info->user_data);
+ }
+ if (trust & (PROFILE_SUPPORTED << 4)) { /* Bit 4 & 5- for SAP Supported */
+ profile_info.profile = TRUSTED_PROFILE_SAP;
+ profile_info.supported = TRUE;
+ if (trust & (1 << 5)) /* Bit 5 - for SAP Trusted */
+ profile_info.trusted = TRUE;
+ else
+ profile_info.trusted = FALSE;
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
+ result, &profile_info,
+ event_info->cb, event_info->user_data);
+ }
} else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
const char *address = NULL;
- bluetooth_device_address_t dev_address = { {0} };
+ const char *if_name = NULL;
+ bt_ipsp_connection_info_t bt_ipsp_iface_info;
+ memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
BT_DBG("BT_IPSP_CONNECTED");
- g_variant_get(parameters, "(i&s)", &result, &address);
+ g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
- _bt_convert_addr_string_to_type(dev_address.addr, address);
+ _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
+ memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
_bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
- result, &dev_address,
+ result, &bt_ipsp_iface_info,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
const char *address = NULL;
- bluetooth_device_address_t dev_address = { {0} };
- BT_DBG("BT_IPSP_DISCONNECTED");
-
- g_variant_get(parameters, "(i&s)", &result, &address);
-
- _bt_convert_addr_string_to_type(dev_address.addr, address);
-
- _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
- result, &dev_address,
- event_info->cb, event_info->user_data);
- } else if (strcasecmp(signal_name, BT_IPSP_BT_INTERFACE_INFO) == 0) {
- const char *address = NULL;
const char *if_name = NULL;
- bt_ipsp_interface_info_t ipsp_iface_info;
- memset(&ipsp_iface_info, 0, sizeof(ipsp_iface_info));
+ bt_ipsp_connection_info_t bt_ipsp_iface_info;
+ memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
- BT_DBG("BT_IPSP_BT_INTERFACE_INFO");
+ BT_DBG("BT_IPSP_DISCONNECTED");
g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
- _bt_convert_addr_string_to_type(ipsp_iface_info.btaddr.addr, address);
- memcpy(ipsp_iface_info.if_name, if_name, 16);
+ _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
+ memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
- _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO,
- result, &ipsp_iface_info,
+ _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
+ result, &bt_ipsp_iface_info,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
const char *address = NULL;
_bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
result, ¶ms, event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, BT_PXP_PROPERTY_CHANGED) == 0) {
+ const char *address = NULL;
+ bluetooth_device_address_t dev_address = { {0} };
+ int role, type, level;
+ bt_pxp_property_changed_params_t params;
+
+ BT_DBG("BT_PXP_PROPERTY_CHANGED");
+
+ g_variant_get(parameters, "(isiii)", &result, &address, &role, &type, &level);
+
+ _bt_convert_addr_string_to_type(dev_address.addr, address);
+ memcpy(¶ms.device_address, &dev_address, BLUETOOTH_ADDRESS_LENGTH);
+ params.role = role;
+ params.service_type = type;
+ params.alert_lvl = level;
+
+ _bt_common_event_cb(BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
+ result, ¶ms, event_info->cb, event_info->user_data);
}
}
event_info = (bt_event_info_t *)user_data;
ret_if(event_info == NULL);
-
if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
return;
if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
_bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
result, &dev_address,
event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_CONNECTED) == 0) {
+ BT_INFO_C("Type %s", g_variant_get_type_string(parameters));
+ const char *address = NULL;
+ bluetooth_device_address_t dev_address = { {0} };
+
+ g_variant_get(parameters, "(i&s)", &result, &address);
+
+ BT_DBG("address: %s", address);
+ _bt_convert_addr_string_to_type(dev_address.addr,
+ address);
+ int ctrl = -1, intr = -1;
+ _bt_hid_device_get_fd(address, &ctrl, &intr);
+ if (ctrl != -1 && intr != -1) {
+ new_hid_connection(NULL, ctrl, &dev_address);
+ new_hid_connection(NULL, intr, &dev_address);
+ }
+ } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_DISCONNECTED) == 0) {
+ const char *address = NULL;
+ g_variant_get(parameters, "(i&s)", &result, &address);
+
+ BT_DBG("address: %s", address);
}
}
void __bt_a2dp_source_event_filter(GDBusConnection *connection,
result, &dev_address,
event_info->cb, event_info->user_data);
- if (result != BLUETOOTH_ERROR_NONE) {
+ if (result != BLUETOOTH_ERROR_NONE)
__bt_remove_push_request_id(request_id);
- }
+
} else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
const char *address = NULL;
int request_id = 0;
__bt_remove_push_request_id(request_id);
} else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
const char *file_name = NULL;
+ const char *device_addr = NULL;
int request_id = 0;
guint64 size = 0;
bt_opc_transfer_info_t transfer_info;
- g_variant_get(parameters, "(i&sti)", &result, &file_name,
+ g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
&size, &request_id);
if (__bt_is_request_id_exist(request_id) == FALSE) {
memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
transfer_info.filename = g_strdup(file_name);
+ transfer_info.device_addr = g_strdup(device_addr);
transfer_info.size = size;
_bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
result, &transfer_info,
event_info->cb, event_info->user_data);
+ g_free(transfer_info.device_addr);
g_free(transfer_info.filename);
} else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
const char *file_name = NULL;
g_free(transfer_info.filename);
} else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
const char *file_name = NULL;
+ const char *device_addr = NULL;
int request_id = 0;
guint64 size = 0;
bt_opc_transfer_info_t transfer_info;
- g_variant_get(parameters, "(i&sti)", &result,
+ g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
&file_name, &size, &request_id);
if (__bt_is_request_id_exist(request_id) == FALSE) {
memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
+ transfer_info.device_addr = g_strdup(device_addr);
transfer_info.filename = g_strdup(file_name);
transfer_info.size = size;
result, &transfer_info,
event_info->cb, event_info->user_data);
+ g_free(transfer_info.device_addr);
g_free(transfer_info.filename);
}
}
if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
/* Native only event */
const char *file_name = NULL;
+ const char *address = NULL;
+ const char *device_name = NULL;
guint64 size = 0;
bt_obex_server_authorize_into_t auth_info;
- g_variant_get(parameters, "(i&st)", &result, &file_name, &size);
+ g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
+ &address, &device_name);
/* OSP server: Don't get this event */
ret_if(obex_server_id == BT_CUSTOM_SERVER);
auth_info.filename = g_strdup(file_name);
auth_info.length = size;
-
+ auth_info.address = g_strdup(address);
+ auth_info.name = g_strdup(device_name);
_bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
result, &auth_info,
event_info->cb, event_info->user_data);
g_free(auth_info.filename);
+ g_free(auth_info.address);
+ g_free(auth_info.name);
} else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
/* OSP only event */
const char *address = NULL;
result, &dev_address,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
+ bt_obex_server_connection_info_t conn_info = {0, };
+ char *address = NULL;
+ char *name = NULL;
+ int transfer_id = -1;
+ g_variant_get(parameters, "(i&s&si)", &result,
+ &address, &name, &transfer_id);
- g_variant_get(parameters, "(i)", &result);
+ conn_info.address = g_strdup(address);
+ conn_info.device_name = g_strdup(name);
+ conn_info.transfer_id = transfer_id;
_bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
- result, NULL, event_info->cb,
+ result, &conn_info, event_info->cb,
event_info->user_data);
+
+ g_free(conn_info.address);
+ g_free(conn_info.device_name);
} else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
+ bt_obex_server_transfer_info_t transfer_info = {0, };
+ char *address = NULL;
+ int transfer_id = -1;
+ g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
+ DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
- g_variant_get(parameters, "(i)", &result);
+ transfer_info.address = g_strdup(address);
+ transfer_info.transfer_id = transfer_id;
_bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
- result, NULL, event_info->cb,
+ result, &transfer_info, event_info->cb,
event_info->user_data);
+ g_free(transfer_info.address);
} else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
+ const char *device_name = NULL;
const char *file_name = NULL;
const char *type = NULL;
+ const char *address = NULL;
+ GVariantIter *iter = NULL;
+ int i = 0;
+ guchar byte;
int transfer_id = 0;
int server_type = 0; /* bt_server_type_t */
guint64 size = 0;
bt_obex_server_transfer_info_t transfer_info;
- g_variant_get(parameters, "(i&s&stii)", &result, &file_name,
- &type, &size, &transfer_id, &server_type);
+ g_variant_get(parameters, "(i&s&s&s&stii(ay))", &result, &device_name,
+ &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
/* Other server's event */
ret_if(obex_server_id != server_type &&
memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
+ transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
+
+ for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
+ transfer_info.contact_auth_info[i] = byte;
+
+ transfer_info.device_name = g_strdup(device_name);
transfer_info.filename = g_strdup(file_name);
transfer_info.type = g_strdup(type);
+ transfer_info.address = g_strdup(address);
transfer_info.file_size = size;
transfer_info.transfer_id = transfer_id;
transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
g_free(transfer_info.filename);
g_free(transfer_info.type);
+ g_free(transfer_info.device_name);
+ g_free(transfer_info.address);
+ g_free(transfer_info.contact_auth_info);
+ g_variant_iter_free(iter);
} else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
const char *file_name = NULL;
const char *type = NULL;
+ const char *device_name = NULL;
+ const char *address = NULL;
int transfer_id = 0;
int progress = 0;
int server_type = 0; /* bt_server_type_t */
guint64 size = 0;
bt_obex_server_transfer_info_t transfer_info;
- g_variant_get(parameters, "(i&s&stiii)", &result, &file_name,
- &type, &size, &transfer_id,
+ g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
+ &type, &device_name, &address, &size, &transfer_id,
&progress, &server_type);
/* Other server's event */
transfer_info.filename = g_strdup(file_name);
transfer_info.type = g_strdup(type);
+ transfer_info.device_name = g_strdup(device_name);
+ transfer_info.address = g_strdup(address);
transfer_info.file_size = size;
transfer_info.transfer_id = transfer_id;
transfer_info.percentage = progress;
event_info->cb, event_info->user_data);
g_free(transfer_info.filename);
+ g_free(transfer_info.device_name);
+ g_free(transfer_info.address);
g_free(transfer_info.type);
} else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
const char *file_name = NULL;
const char *device_name = NULL;
+ const char *address = NULL;
const char *type = NULL;
const char *file_path;
int transfer_id = 0;
guint64 size = 0;
bt_obex_server_transfer_info_t transfer_info;
- g_variant_get(parameters, "(i&s&s&s&stii)", &result, &file_name,
- &type, &device_name, &file_path, &size,
+ g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
+ &type, &device_name, &file_path, &address, &size,
&transfer_id, &server_type);
/* Other server's event */
transfer_info.type = g_strdup(type);
transfer_info.device_name = g_strdup(device_name);
transfer_info.file_path = g_strdup(file_path);
+ transfer_info.address = g_strdup(address);
transfer_info.file_size = size;
transfer_info.transfer_id = transfer_id;
transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
g_free(transfer_info.filename);
g_free(transfer_info.type);
g_free(transfer_info.device_name);
+ g_free(transfer_info.address);
g_free(transfer_info.file_path);
}
}
bt_event_info_t *event_info;
int result = BLUETOOTH_ERROR_NONE;
event_info = (bt_event_info_t *)user_data;
+
ret_if(event_info == NULL);
if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
return;
+
if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
return;
ret_if(signal_name == NULL);
+
BT_DBG("Type: %s", g_variant_get_type_string(parameters));
+
if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
bt_pbap_connected_t connected = { { { 0 }, }, };
char *address = NULL;
- g_variant_get(parameters, "(is)", &result, &address);
+ g_variant_get(parameters, "(i&s)", &result, &address);
BT_DBG("address: %s", address);
_bt_convert_addr_string_to_type(connected.btaddr.addr,
address);
-
- connected.connected = 1;
+ if (result == 0)
+ connected.connected = 1;
+ else
+ connected.connected = 0;
_bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
result, &connected,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
- bt_pbap_connected_t connected = { { { 0 }, }, };
- char *address = NULL;
-
- g_variant_get(parameters, "(is)", &result, &address);
- BT_DBG("address: %s", address);
-
- _bt_convert_addr_string_to_type(connected.btaddr.addr,
- address);
-
- connected.connected = 0;
-
- _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
- result, &connected,
- event_info->cb, event_info->user_data);
- } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
bt_pbap_connected_t disconnected = { { { 0 }, }, };
char *address = NULL;
- g_variant_get(parameters, "(is)", &result, &address);
+ g_variant_get(parameters, "(i&s)", &result, &address);
BT_DBG("address: %s", address);
_bt_convert_addr_string_to_type(disconnected.btaddr.addr,
address);
disconnected.connected = 0;
- _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
+ _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
result, &disconnected,
event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
char *address = NULL;
int size = 0;
- g_variant_get(parameters, "(isi)", &result, &address, &size);
+ g_variant_get(parameters, "(i&si)", &result, &address, &size);
- BT_DBG("address: %s", address);
- BT_DBG("size: %d", size);
+ BT_DBG("address: %s, size: %d", address, size);
_bt_convert_addr_string_to_type(pb_size.btaddr.addr,
address);
char *vcf_file = NULL;
int success = -1;
- g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
+ g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
- BT_DBG("address: %s", address);
- BT_DBG("vcf_file: %s", vcf_file);
- BT_DBG("success: %d", success);
+ BT_DBG("address: %s, vcf_file: %s, success: %d",
+ address, vcf_file, success);
_bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
address);
int success = -1;
int i = 0;
- g_variant_get(parameters, "(isv)", &result, &address, &string_var);
+ g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
list = (gchar **)g_variant_get_strv(string_var, &count);
success = !result;
- BT_DBG("address: %s", address);
- BT_DBG("result: %d", result);
- BT_DBG("count: %d", count);
+
for (i = 0; i < count; i++)
BT_DBG("%s", list[i]);
- BT_DBG("success: %d", success);
+
+ BT_DBG("address: %s, result: %d, count: %d, success: %d",
+ address, result, count, success);
_bt_convert_addr_string_to_type(vc_list.btaddr.addr,
address);
char *vcf_file = NULL;
int success = -1;
- g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
+ g_variant_get(parameters, "(i&s&si)",
+ &result, &address, &vcf_file, &success);
- BT_DBG("address: %s", address);
- BT_DBG("vcf_file: %s", vcf_file);
- BT_DBG("success: %d", success);
+ BT_DBG("address: %s, vcf_file: %s, success: %d",
+ address, vcf_file, success);
- _bt_convert_addr_string_to_type(vc_pull.btaddr.addr,
- address);
+ _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
vc_pull.vcf_file = vcf_file;
vc_pull.success = success;
_bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
int success = -1;
int i = 0;
- g_variant_get(parameters, "(is@as)", &result, &address, &string_var);
+ g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
list = (gchar **)g_variant_get_strv(string_var, &count);
success = !result;
- BT_DBG("address: %s", address);
for (i = 0; i < count; i++)
BT_DBG("%s", list[i]);
- BT_DBG("success: %d", success);
- _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
- address);
+ BT_DBG("address: %s success: %d", address, success);
+
+ _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
vc_list.vcards = list;
vc_list.length = count;
vc_list.success = success;
memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
_bt_convert_addr_string_to_type(req_ind.device_addr.addr,
address);
+
req_ind.socket_fd = socket_fd;
_bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
_bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
result, NULL,
event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, "FailedToDial") == 0) {
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
+ result, NULL,
+ event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, "CallIdle") == 0) {
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
+ result, NULL,
+ event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
+ result, NULL,
+ event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
+ result, NULL,
+ event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
+ result, NULL,
+ event_info->cb, event_info->user_data);
} else if (strcasecmp(signal_name, "CallStarted") == 0) {
_bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
result, NULL,
_bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
result, &cmd,
event_info->cb, event_info->user_data);
+ } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
+ GVariant *value;
+ gchar *property;
+ bluetooth_hf_ciev_device_event_t dev_event;
+
+ g_variant_get(parameters, "(&sv)", &property, &value);
+ dev_event.value = g_variant_get_uint16(value);
+
+ BT_DBG("Property: %s , value: %d", property, dev_event.value);
+ g_variant_unref(value);
+
+ if (strcasecmp(property, "BatteryCharge") == 0) {
+ dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
+ result, &dev_event,
+ event_info->cb, event_info->user_data);
+ } else if (strcasecmp(property, "SignalStrength") == 0) {
+ dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
+ result, &dev_event,
+ event_info->cb, event_info->user_data);
+ } else if (strcasecmp(property, "RegistrationStatus") == 0) {
+ dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
+ _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
+ result, &dev_event,
+ event_info->cb, event_info->user_data);
+ }
}
BT_DBG("-\n");
}
static void __bt_remove_all_events(void)
{
- GSList *l;
bt_event_info_t *info;
- for (l = event_list; l != NULL; l = g_slist_next(l)) {
- info = l->data;
+ while ((info = g_slist_nth_data(event_list, 0)) != NULL)
+ _bt_unregister_event(info->event_type);
- if (info)
- _bt_unregister_event(info->event_type);
+ if (event_list) {
+ g_slist_free(event_list);
+ event_list = NULL;
}
-
- g_slist_free(event_list);
- event_list = NULL;
}
static gboolean __bt_event_is_registered(int event_type)
if (info == NULL)
continue;
- if (info->server_fd == server_fd) {
+ if (info->server_fd == server_fd)
server_list = g_slist_remove(server_list, (void *)info);
- }
g_free(info);
}
owner_sig_id = -1;
}
}
+
+static void __bt_manager_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)
+{
+ char *path = NULL;
+ GVariantIter *interface_iter = NULL;
+ char *interface_str = NULL;
+ bt_gatt_service_change_t change;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ bt_user_info_t *user_info = NULL;
+
+ if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
+ g_variant_get(parameters, "(&s)", &path);
+
+ _bt_convert_device_path_to_address(path, address);
+ _bt_convert_addr_string_to_type(change.device_addr.addr, address);
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+
+ if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
+ == FALSE) {
+ BT_INFO("GATT Service [%s] added, but no watcher for %s",
+ path, secure_address);
+ return;
+ } else
+ BT_INFO("GATT Service [%s] added : %s",
+ path, secure_address);
+
+ change.svc_path = g_strdup(path);
+ change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
+
+ user_info = _bt_get_user_data(BT_COMMON);
+ if (user_info != NULL) {
+ _bt_common_event_cb(
+ BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
+ BLUETOOTH_ERROR_NONE, &change,
+ user_info->cb, user_info->user_data);
+ }
+
+ g_free(change.svc_path);
+ } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
+ g_variant_get(parameters, "(&oas)",
+ &path, &interface_iter);
+
+ if (!path) {
+ BT_ERR("Invalid adapter path");
+ return;
+ }
+
+ _bt_convert_device_path_to_address(path, address);
+ _bt_convert_addr_string_to_type(change.device_addr.addr, address);
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+
+ if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
+ == FALSE) {
+ BT_INFO("GATT Service [%s] removed, but no watcher for %s",
+ path, secure_address);
+ return;
+ }
+
+ while (g_variant_iter_loop(interface_iter, "s", &interface_str)) {
+ if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) == 0) {
+ change.svc_path = g_strdup(path);
+ change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
+
+ BT_INFO("GATT Service [%s] is removed : %s",
+ path, secure_address);
+
+ user_info = _bt_get_user_data(BT_COMMON);
+ if (user_info != NULL) {
+ _bt_common_event_cb(
+ BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
+ BLUETOOTH_ERROR_NONE, &change,
+ user_info->cb, user_info->user_data);
+ }
+
+ g_free(change.svc_path);
+ break;
+ }
+ }
+ g_variant_iter_free(interface_iter);
+ }
+}
+
+int _bt_register_manager_subscribe_signal(gboolean subscribe)
+{
+ GDBusConnection *g_conn;
+ static int service_added_id = -1;
+ static int interface_removed_id = -1;
+
+ g_conn = _bt_gdbus_get_system_gconn();
+ if (g_conn == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ if (subscribe == TRUE) {
+ if (service_added_id == -1) {
+ service_added_id = g_dbus_connection_signal_subscribe(g_conn,
+ NULL, GATT_SERV_INTERFACE,
+ "GattServiceAdded", NULL, NULL, 0,
+ __bt_manager_event_filter,
+ NULL, NULL);
+ }
+ if (interface_removed_id == -1) {
+ interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
+ NULL, BT_MANAGER_INTERFACE,
+ "InterfacesRemoved", NULL, NULL, 0,
+ __bt_manager_event_filter,
+ NULL, NULL);
+ }
+ } else {
+ if (service_added_id != -1) {
+ g_dbus_connection_signal_unsubscribe(g_conn,
+ service_added_id);
+ service_added_id = -1;
+ }
+ if (interface_removed_id != -1) {
+ g_dbus_connection_signal_unsubscribe(g_conn,
+ interface_removed_id);
+ interface_removed_id = -1;
+ }
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
#include <stdint.h>
#include "bt-common.h"
+#include "bt-event-handler.h"
+#include "bt-gatt-client.h"
#include "bt-internal-types.h"
#include "bt-request-sender.h"
-#define GATT_SERV_INTERFACE "org.bluez.GattService1"
-#define GATT_CHAR_INTERFACE "org.bluez.GattCharacteristic1"
-#define GATT_DESC_INTERFACE "org.bluez.GattDescriptor1"
-
-#define GATT_USER_DESC_UUID "00002901-0000-1000-8000-00805f9b34fb"
-#define GATT_CHAR_CLIENT_CONF "00002902-0000-1000-8000-00805f9b34fb"
-#define GATT_CHAR_SERVER_CONF "00002903-0000-1000-8000-00805f9b34fb"
-#define GATT_CHAR_FORMAT "00002904-0000-1000-8000-00805f9b34fb"
+#define GATT_DEFAULT_TIMEOUT (6 * 1000) // Dependent on supervision timeout 6 sec
typedef enum {
TYPE_NONE,
CHAR_FORMAT
} char_descriptor_type_t;
+static GSList *service_monitor_list = NULL;
+
BT_EXPORT_API int bluetooth_gatt_free_service_property(bt_gatt_service_property_t *svc_pty)
{
BT_DBG("+");
return path;
}
+gboolean _bluetooth_gatt_check_service_change_watcher_address(
+ const bluetooth_device_address_t *device_addr)
+{
+ GSList *l;
+ char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ _bt_convert_addr_type_to_string(device_address,
+ (unsigned char *)device_addr->addr);
+
+ for (l = service_monitor_list; l != NULL; l = l->next) {
+ char device_address2[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char secure_address2[BT_ADDRESS_STRING_SIZE] = { 0 };
+ bluetooth_device_address_t *addr = l->data;
+
+ _bt_convert_addr_type_to_string(device_address2,
+ (unsigned char *)addr->addr);
+ _bt_convert_addr_string_to_secure_string(secure_address,
+ device_address);
+ _bt_convert_addr_string_to_secure_string(secure_address2,
+ device_address2);
+ BT_INFO("service_monitor_list [%s] - Input [%s]",
+ secure_address2, secure_address);
+
+ if (!memcmp(device_addr, addr,
+ sizeof(bluetooth_device_address_t)))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+BT_EXPORT_API int bluetooth_gatt_set_service_change_watcher(
+ const bluetooth_device_address_t *address, gboolean enable)
+{
+ GSList *l;
+ bluetooth_device_address_t *addr = NULL;
+ char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ _bt_convert_addr_type_to_string(device_address,
+ (unsigned char *)address->addr);
+ _bt_convert_addr_string_to_secure_string(secure_address,
+ device_address);
+ BT_INFO("Set watcher for %s with %d", secure_address, enable);
+
+ if (enable == TRUE) {
+ if (service_monitor_list == NULL)
+ _bt_register_manager_subscribe_signal(TRUE);
+
+ if (_bluetooth_gatt_check_service_change_watcher_address(address)
+ == TRUE) {
+ BT_INFO("The watcher is already set");
+ return BLUETOOTH_ERROR_NONE;
+ }
+ addr = g_malloc0(sizeof(bluetooth_device_address_t));
+ memcpy(addr, address, sizeof(bluetooth_device_address_t));
+
+ if (service_monitor_list == NULL) {
+ BT_ERR("There is NO watcher");
+ return BLUETOOTH_ERROR_NONE;
+ }
+
+ service_monitor_list =
+ g_slist_append(service_monitor_list, addr);
+ } else {
+ if (service_monitor_list == NULL) {
+ BT_ERR("There is NO watcher");
+ return BLUETOOTH_ERROR_NONE;
+ }
+
+ for (l = service_monitor_list; l != NULL; l = l->next) {
+ addr = l->data;
+ if (!memcmp(address, addr,
+ sizeof(bluetooth_device_address_t))) {
+ service_monitor_list =
+ g_slist_remove(service_monitor_list, addr);
+ g_free(addr);
+ break;
+ }
+ }
+
+ if (service_monitor_list == NULL)
+ _bt_register_manager_subscribe_signal(FALSE);
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
BT_EXPORT_API int bluetooth_gatt_get_service_property(const char *service_handle,
bt_gatt_service_property_t *service)
{
gsize len;
char *char_handle = NULL;
GPtrArray *gp_array = NULL ;
- GVariantIter *property_iter, *char_iter;
+ GVariantIter *property_iter, *char_iter = NULL;
const gchar *key;
GVariant *value;
BT_CHECK_PARAMETER(service_handle, return);
BT_CHECK_PARAMETER(service, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
if (!g_strcmp0(key, "UUID")) {
+ char *name = NULL;
service->uuid = g_variant_dup_string(value, &len);
+ _bt_get_uuid_specification_name(service->uuid, &name);
+ BT_INFO("======> Service : %s [%s]", service->uuid, name);
+ g_free(name);
} else if (!g_strcmp0(key, "Primary")) {
service->primary = g_variant_get_boolean(value);
} else if (!g_strcmp0(key, "Includes")) {
g_variant_get(value, "ao", &char_iter);
gp_array = g_ptr_array_new();
- while (g_variant_iter_loop(char_iter, "&o", &char_handle)) {
+ while (g_variant_iter_loop(char_iter, "&o", &char_handle))
g_ptr_array_add(gp_array, (gpointer)char_handle);
- }
+
if (gp_array->len != 0) {
service->include_handles.count = gp_array->len;
service->include_handles.handle =
__get_string_array_from_gptr_array(gp_array);
}
g_ptr_array_free(gp_array, TRUE);
+ g_variant_iter_free(char_iter);
} else if (!g_strcmp0(key, "Characteristics")) {
g_variant_get(value, "ao", &char_iter);
gp_array = g_ptr_array_new();
- while (g_variant_iter_loop(char_iter, "&o", &char_handle)) {
+ while (g_variant_iter_loop(char_iter, "&o", &char_handle))
g_ptr_array_add(gp_array, (gpointer)char_handle);
- }
+
if (gp_array->len != 0) {
service->char_handle.count = gp_array->len;
service->char_handle.handle =
__get_string_array_from_gptr_array(gp_array);
}
+ BT_DBG("Characteristics count : %d", service->char_handle.count);
g_ptr_array_free(gp_array, TRUE);
+ g_variant_iter_free(char_iter);
}
}
BT_INFO("+");
BT_CHECK_PARAMETER(address, return);
BT_CHECK_PARAMETER(prim_svc, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
result = _bt_get_managed_objects();
if (result == NULL)
BT_CHECK_PARAMETER(address, return);
BT_CHECK_PARAMETER(service_uuid, return);
BT_CHECK_PARAMETER(service, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
result = _bt_get_managed_objects();
if (result == NULL)
g_strfreev(svc_char.handle_info.handle);
g_free(svc_char.service_handle);
g_variant_iter_free(char_iter);
+ g_variant_unref(value);
g_object_unref(proxy);
}
BT_DBG("+");
BT_CHECK_PARAMETER(service_handle, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
retv_if(permission == NULL, ret);
- BT_DBG("permission = %s", permission);
+ BT_INFO("permission = %s", permission);
- if (!g_strcmp0(permission, "broadcast")) {
+ if (!g_strcmp0(permission, "broadcast"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_BROADCAST;
- } else if (!g_strcmp0(permission, "read")) {
+ else if (!g_strcmp0(permission, "read"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ;
- } else if (!g_strcmp0(permission, "write-without-response")) {
+ else if (!g_strcmp0(permission, "write-without-response"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE_NO_RESPONSE;
- } else if (!g_strcmp0(permission, "write")) {
+ else if (!g_strcmp0(permission, "write"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE;
- } else if (!g_strcmp0(permission, "notify")) {
+ else if (!g_strcmp0(permission, "notify"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY;
- } else if (!g_strcmp0(permission, "indicate")) {
+ else if (!g_strcmp0(permission, "indicate"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
- } else if (!g_strcmp0(permission, "authenticated-signed-writes")) {
+ else if (!g_strcmp0(permission, "authenticated-signed-writes"))
ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_SIGNED_WRITE;
- } else if (!g_strcmp0(permission, "reliable-write")) {
- ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_EXTENDED_PROPS;
- } else if (!g_strcmp0(permission, "writable-auxiliaries")) {
- ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_EXTENDED_PROPS;
- }
+ else if (!g_strcmp0(permission, "reliable-write"))
+ ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_RELIABLE_WRITE;
+ else if (!g_strcmp0(permission, "writable-auxiliaries"))
+ ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITABLE_AUXILIARIES;
+ else if (!g_strcmp0(permission, "encrypt-read"))
+ ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_READ;
+ else if (!g_strcmp0(permission, "encrypt-write"))
+ ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_WRITE;
+ else if (!g_strcmp0(permission, "encrypt-authenticated-read"))
+ ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_READ;
+ else if (!g_strcmp0(permission, "encrypt-authenticated-write"))
+ ret = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_WRITE;
return ret;
}
BT_CHECK_PARAMETER(char_handle, return);
BT_CHECK_PARAMETER(characteristic, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
characteristic->handle = g_strdup(char_handle);
while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
- BT_DBG("property");
if (!g_strcmp0(key, "UUID")) {
+ char *name = NULL;
characteristic->uuid = g_variant_dup_string(value, &len);
- BT_DBG("UUID of the char = %s", characteristic->uuid);
+ _bt_get_uuid_specification_name(characteristic->uuid, &name);
+ BT_INFO("Characteristic : %s [%s]", characteristic->uuid, name);
+ g_free(name);
} else if (!g_strcmp0(key, "Value")) {
gb_array = g_byte_array_new();
g_variant_get(value, "ay", &char_value_iter);
while (g_variant_iter_loop(char_value_iter, "y", &char_value)) {
- BT_DBG("value of char = %d", char_value);
+ // BT_DBG("value of char = %d",char_value);
g_byte_array_append(gb_array, &char_value, 1);
}
g_variant_iter_free(char_value_iter);
} else if (!g_strcmp0(key, "Descriptors")) {
g_variant_get(value, "ao", &char_desc_iter);
gp_array = g_ptr_array_new();
- while (g_variant_iter_loop(char_desc_iter, "&o", &char_desc_handle)) {
+ while (g_variant_iter_loop(char_desc_iter, "&o", &char_desc_handle))
g_ptr_array_add(gp_array, (gpointer)char_desc_handle);
- }
+
g_variant_iter_free(char_desc_iter);
if (gp_array->len != 0) {
characteristic->char_desc_handle.count = gp_array->len;
{
GVariant *value;
GVariantIter *char_iter;
- int i, len;
char *char_handle;
GError *error = NULL;
bt_user_info_t *user_info;
g_variant_get(value, "(ao)", &char_iter);
- len = g_variant_get_size((GVariant *)char_iter);
-
- for (i = 0; i < len; i++) {
- g_variant_iter_loop(char_iter, "o", &char_handle);
+ while (g_variant_iter_loop(char_iter, "&o", &char_handle)) {
if (!char_handle)
continue;
ret = bluetooth_gatt_get_characteristics_property(char_handle,
bluetooth_gatt_free_char_property(&characteristic);
g_variant_iter_free(char_iter);
+ g_variant_unref(value);
g_free(user_data);
}
BT_CHECK_PARAMETER(service_handle, return);
BT_CHECK_PARAMETER(char_uuid, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
BT_CHECK_PARAMETER(descriptor_handle, return);
BT_CHECK_PARAMETER(descriptor, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
descriptor->handle = g_strdup(descriptor_handle);
while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
- BT_DBG("property");
if (!g_strcmp0(key, "UUID")) {
+ char *name = NULL;
descriptor->uuid = g_variant_dup_string(value, &len);
- BT_DBG("UUID of the char_desc = %s", descriptor->uuid);
+ _bt_get_uuid_specification_name(descriptor->uuid, &name);
+ BT_INFO("Descriptor : %s [%s]", descriptor->uuid, name);
+ g_free(name);
} else if (!g_strcmp0(key, "Value")) {
gb_array = g_byte_array_new();
g_variant_get(value, "ay", &desc_value_iter);
g_byte_array_append(gb_array, &char_value, 1);
}
g_variant_iter_free(desc_value_iter);
+
if (gb_array->len != 0) {
descriptor->val = g_malloc0(gb_array->len *
sizeof(unsigned char));
GByteArray *gp_byte_array = NULL;
GVariantIter *iter;
guint8 g_byte;
+ int ret = BLUETOOTH_ERROR_NONE;
BT_DBG("+");
user_info = _bt_get_user_data(BT_COMMON);
if (error) {
BT_ERR("Error : %s \n", error->message);
+ if (g_strrstr(error->message, "Not paired"))
+ ret = BLUETOOTH_ERROR_NOT_PAIRED;
+ else
+ ret = BLUETOOTH_ERROR_INTERNAL;
+
g_clear_error(&error);
if (user_info) {
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
- BLUETOOTH_ERROR_INTERNAL, NULL,
+ ret, NULL,
user_info->cb, user_info->user_data);
}
g_free(user_data);
gp_byte_array = g_byte_array_new();
g_variant_get(value, "(ay)", &iter);
- while (g_variant_iter_loop(iter, "y", &g_byte)) {
+ while (g_variant_iter_loop(iter, "y", &g_byte))
g_byte_array_append(gp_byte_array, &g_byte, 1);
- }
if (gp_byte_array->len != 0) {
char_value.val_len = gp_byte_array->len;
char *handle;
BT_CHECK_PARAMETER(characteristic, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
BT_CHECK_PARAMETER(char_handle, return);
BT_CHECK_PARAMETER(value, return);
retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < length; i++) {
+ for (i = 0; i < length; i++)
g_variant_builder_add(builder, "y", value[i]);
- }
val = g_variant_new("(ay)", builder);
GDBusConnection *system_gconn = NULL;
GVariant *value;
int result = BLUETOOTH_ERROR_NONE;
+ guint8 att_ecode = 0;
user_info = _bt_get_user_data(BT_COMMON);
BT_ERR("Error : %s \n", error->message);
g_clear_error(&error);
result = BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ g_variant_get(value, "(y)", &att_ecode);
+ if (att_ecode) {
+ result = att_ecode;
+ BT_ERR("ATT Error code: %d \n", att_ecode);
+ }
}
+
if (user_info) {
- BT_DBG("result = %d", result);
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
result, NULL,
user_info->cb, user_info->user_data);
+ } else {
+ BT_ERR("user info is null");
}
if (value)
BT_CHECK_PARAMETER(char_handle, return);
BT_CHECK_PARAMETER(value, return);
retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED_INTERNAL(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < length; i++) {
+ for (i = 0; i < length; i++)
g_variant_builder_add(builder, "y", value[i]);
- }
val = g_variant_new("ay", builder);
g_dbus_connection_call(conn,
GATT_CHAR_INTERFACE,
"WriteValuebyType",
g_variant_new("(y@ay)", write_type, val),
- NULL,
+ G_VARIANT_TYPE("(y)"),
G_DBUS_CALL_FLAGS_NONE,
-1, NULL,
(GAsyncReadyCallback)__bluetooth_internal_write_cb,
BT_CHECK_PARAMETER(char_handle, return);
BT_CHECK_PARAMETER(value, return);
retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
bluetooth_gatt_free_char_property(&characteristic);
g_variant_iter_free(char_iter);
+ g_variant_unref(value);
BT_DBG("-");
}
GError *error = NULL;
BT_CHECK_PARAMETER(characteristic_handle, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
BT_DBG("+");
BT_CHECK_PARAMETER(char_descriptor, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
GDBusConnection *system_gconn = NULL;
GVariant *value;
int result = BLUETOOTH_ERROR_NONE;
+ guint8 att_ecode = 0;
BT_DBG("+");
user_info = _bt_get_user_data(BT_COMMON);
BT_ERR("Error : %s \n", error->message);
g_clear_error(&error);
result = BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ g_variant_get(value, "(y)", &att_ecode);
+ if (att_ecode) {
+ result = att_ecode;
+ BT_ERR("ATT Error code: %d \n", att_ecode);
+ }
}
+
if (user_info) {
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
result, NULL,
BT_CHECK_PARAMETER(desc_handle, return);
BT_CHECK_PARAMETER(value, return);
retv_if(length == 0, BLUETOOTH_ERROR_INVALID_PARAM);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < length; i++) {
+ for (i = 0; i < length; i++)
g_variant_builder_add(builder, "y", value[i]);
- }
val = g_variant_new("(ay)", builder);
GATT_DESC_INTERFACE,
"WriteValue",
val,
- NULL,
+ G_VARIANT_TYPE("(y)"),
G_DBUS_CALL_FLAGS_NONE,
-1, NULL,
(GAsyncReadyCallback)__bluetooth_internal_write_desc_cb,
BT_ERR("Watch Characteristic request failed !");
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
return result;
}
#endif
BT_EXPORT_API int bluetooth_gatt_watch_characteristics(const char *char_handle)
{
-
GDBusConnection *conn;
GError *error = NULL;
int ret = BLUETOOTH_ERROR_NONE;
- BT_DBG("+");
- BT_CHECK_PARAMETER(char_handle, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_PARAMETER(char_handle, return);
+ BT_CHECK_ENABLED(return);
- BT_DBG("Entered characteristic handle:%s \n ", char_handle);
+ BT_INFO_C("### Enable CCCD : %s", char_handle);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
NULL,
NULL,
G_DBUS_CALL_FLAGS_NONE,
- -1, NULL, &error);
+ GATT_DEFAULT_TIMEOUT, NULL, &error);
if (error) {
- BT_ERR("Watch Failed: %s", error->message);
+ g_dbus_error_strip_remote_error(error);
+ BT_ERR_C("### Watch Failed: %s", error->message);
if (g_strrstr(error->message, "Already notifying"))
ret = BLUETOOTH_ERROR_NONE;
else if (g_strrstr(error->message, "In Progress"))
}
#ifndef GATT_NO_RELAY
-static void __bluetooth_gatt_unwatch_characteristics(void)
+static int __bluetooth_gatt_unwatch_characteristics(void)
{
int result = BLUETOOTH_ERROR_NONE;
BT_ERR("Unwatch Characteristic request failed !");
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
}
#endif
BT_DBG("+");
BT_CHECK_PARAMETER(char_handle, return);
- BT_CHECK_ENABLED_ANY(return);
+ BT_CHECK_ENABLED(return);
- BT_DBG("Entered characteristic handle:%s \n ", char_handle);
+ BT_INFO("Disable CCCD : %s", char_handle);
conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
NULL,
NULL,
G_DBUS_CALL_FLAGS_NONE,
- -1, NULL, &error);
+ GATT_DEFAULT_TIMEOUT, NULL, &error);
if (error) {
BT_ERR("Watch Failed: %s", error->message);
#ifndef GATT_NO_RELAY
else {
/* Unregister the client sender to bt-service */
- __bluetooth_gatt_unwatch_characteristics();
+ ret = __bluetooth_gatt_unwatch_characteristics();
}
#endif
BT_DBG("-");
#include<stdlib.h>
#include<unistd.h>
#include<stdint.h>
+#include<stdbool.h>
#include "bt-common.h"
#include "bt-internal-types.h"
static gboolean new_char = FALSE;
static int serv_id = 1;
static int register_pending_cnt = 0;
+static bool is_server_started = false;
/* Introspection data for the service we are exporting */
static const gchar service_introspection_xml[] =
static struct gatt_req_info *__bt_gatt_find_request_info(guint request_id);
+static void __bt_gatt_close_gdbus_connection(void)
+{
+ GError *err = NULL;
+
+ BT_DBG("+");
+
+ ret_if(g_conn == NULL);
+
+ if (!g_dbus_connection_flush_sync(g_conn, NULL, &err)) {
+ BT_ERR("Fail to flush the connection: %s", err->message);
+ g_error_free(err);
+ err = NULL;
+ }
+
+ if (!g_dbus_connection_close_sync(g_conn, NULL, &err)) {
+ if (err) {
+ BT_ERR("Fail to close the dbus connection: %s", err->message);
+ g_error_free(err);
+ }
+ }
+
+ g_object_unref(g_conn);
+
+ g_conn = NULL;
+
+ BT_DBG("-");
+}
+
#ifdef HPS_FEATURE
static int __bt_send_event_to_hps(int event, GVariant *var)
{
GDBusMethodInvocation *invocation,
gpointer user_data)
{
- GSList *l1;
+ GSList *l1 = NULL;
int len = 0;
int i = 0;
GVariantBuilder *svc_builder = NULL;
GVariantBuilder *inner_builder = NULL;
- if (register_pending_cnt > 1) {
+ if (register_pending_cnt > 1)
l1 = g_slist_nth(gatt_services, len - register_pending_cnt);
- } else {
+ else
l1 = g_slist_last(gatt_services);
- }
+
register_pending_cnt--;
+ if (l1 == NULL) {
+ BT_ERR("gatt service list is NULL");
+ g_dbus_method_invocation_return_value(invocation, NULL);
+ return;
+ }
+
struct gatt_service_info *serv_info = l1->data;
if (serv_info == NULL) {
BT_ERR("service info value is NULL");
if (introspection_data == NULL)
return NULL;
+
+ BT_DBG("Create new node info");
node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
if (err) {
BT_ERR("Unable to create node: %s", err->message);
g_clear_error(&err);
+ return NULL;
}
+
return node_info;
}
for (l = gatt_requests; l != NULL; l = l->next) {
struct gatt_req_info *req_info = l->data;
- if (req_info && req_info->request_id == request_id) {
+ if (req_info && req_info->request_id == request_id)
return req_info;
- }
}
BT_ERR("Gatt Request not found");
return NULL;
error->code, error->message);
g_clear_error(&error);
}
+ } else {
+ g_variant_unref(result);
}
}
error->code, error->message);
g_clear_error(&error);
}
+ } else {
+ g_variant_unref(result);
}
}
{
GDBusProxy *proxy = NULL;
- proxy = __bt_gatt_gdbus_get_manager_proxy("org.bluez",
- "/org/bluez/hci0", GATT_MNGR_INTERFACE);
+ if (is_server_started) {
+ proxy = __bt_gatt_gdbus_get_manager_proxy("org.bluez",
+ "/org/bluez/hci0", GATT_MNGR_INTERFACE);
- if (proxy == NULL || app_path == NULL)
- return BLUETOOTH_ERROR_INTERNAL;
+ if (proxy == NULL || app_path == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
- BT_INFO("UnregisterApplication");
+ BT_INFO("UnregisterApplication");
- /* Async Call to Unregister Service */
- g_dbus_proxy_call(proxy,
+ /* Async Call to Unregister Service */
+ g_dbus_proxy_call(proxy,
"UnregisterApplication",
g_variant_new("(o)",
- app_path),
+ app_path),
G_DBUS_CALL_FLAGS_NONE, -1,
NULL,
(GAsyncReadyCallback) unregister_application_cb,
NULL);
+ is_server_started = false;
+ return BLUETOOTH_ERROR_NONE;
+ }
+
+ BT_INFO("GATT server not started");
return BLUETOOTH_ERROR_NONE;
}
static GDBusConnection *__bt_gatt_get_gdbus_connection(void)
{
GDBusConnection *local_system_gconn = NULL;
+ char *address;
GError *err = NULL;
if (g_conn == NULL) {
- g_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (address == NULL) {
+ if (err) {
+ BT_ERR("Failed to get bus address: %s", err->message);
+ g_clear_error(&err);
+ }
+ return NULL;
+ }
+
+ g_conn = g_dbus_connection_new_for_address_sync(address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+ G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
+ NULL, /* GDBusAuthObserver */
+ NULL,
+ &err);
if (!g_conn) {
if (err) {
BT_ERR("Unable to connect to dbus: %s", err->message);
g_clear_error(&err);
}
- g_conn = NULL;
+ return NULL;
}
} else if (g_dbus_connection_is_closed(g_conn)) {
- local_system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (address == NULL) {
+ if (err) {
+ BT_ERR("Failed to get bus address: %s", err->message);
+ g_clear_error(&err);
+ }
+ return NULL;
+ }
+
+ local_system_gconn = g_dbus_connection_new_for_address_sync(address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+ G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
+ NULL, /* GDBusAuthObserver */
+ NULL,
+ &err);
if (!local_system_gconn) {
BT_ERR("Unable to connect to dbus: %s", err->message);
BT_EXPORT_API int bluetooth_gatt_init(void)
{
GDBusConnection *conn;
- GDBusNodeInfo *obj_info;
GError *error = NULL;
+ GDBusNodeInfo *node_info = NULL;
- owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
- BT_GATT_SERVICE_NAME,
- G_BUS_NAME_OWNER_FLAGS_NONE,
- NULL, NULL, NULL, NULL, NULL);
+ if (app_path != NULL) {
+ BT_ERR("app path already exists! initialized");
+ return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
+ }
+
+ if (owner_id == 0) {
+ owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
+ BT_GATT_SERVICE_NAME,
+ G_BUS_NAME_OWNER_FLAGS_NONE,
+ NULL, NULL, NULL, NULL, NULL);
+ }
BT_DBG("owner_id is [%d]", owner_id);
app_path = g_strdup_printf("/com/%d", getpid());
conn = __bt_gatt_get_gdbus_connection();
if (!conn) {
BT_ERR("Unable to get connection");
- return BLUETOOTH_ERROR_INTERNAL;
+ goto failed;
}
/* Register ObjectManager interface */
- obj_info = __bt_gatt_create_method_node_info(
+ node_info = __bt_gatt_create_method_node_info(
manager_introspection_xml);
- if (obj_info == NULL) {
+ if (node_info == NULL) {
BT_ERR("failed to get node info");
- return BLUETOOTH_ERROR_INTERNAL;
+ goto failed;
}
- manager_id = g_dbus_connection_register_object(g_conn, app_path,
- obj_info->interfaces[0],
- &manager_interface_vtable,
- NULL, NULL, &error);
+ if (manager_id == 0) {
+ BT_INFO("manager_id does not exists");
+
+ manager_id = g_dbus_connection_register_object(g_conn, app_path,
+ node_info->interfaces[0],
+ &manager_interface_vtable,
+ NULL, NULL, &error);
+ }
if (manager_id == 0) {
BT_ERR("failed to register: %s", error->message);
g_error_free(error);
- return BLUETOOTH_ERROR_INTERNAL;
+ goto failed;
}
return BLUETOOTH_ERROR_NONE;
+
+failed:
+ if (owner_id)
+ g_bus_unown_name(owner_id);
+
+ g_free(app_path);
+
+ app_path = NULL;
+ owner_id = 0;
+
+ __bt_gatt_close_gdbus_connection();
+
+ return BLUETOOTH_ERROR_INTERNAL;
}
BT_EXPORT_API int bluetooth_gatt_deinit()
int ret = BLUETOOTH_ERROR_NONE;
/* Unown gdbus bus */
if (owner_id) {
-
/* remove/unregister all services */
BT_DBG("removing all registered gatt service\n");
bluetooth_gatt_delete_services();
- g_bus_unown_name(owner_id);
-
/* unregister the exported interface for object manager */
g_dbus_connection_unregister_object(g_conn,
manager_id);
+ manager_id = 0;
+
+ ret = bluetooth_gatt_unregister_application();
+ if (ret != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to unregister application\n");
+
+ g_bus_unown_name(owner_id);
+ owner_id = 0;
+
+ g_free(app_path);
+ app_path = NULL;
+
BT_DBG("Gatt service deinitialized \n");
g_slist_free(gatt_services);
gatt_services = NULL;
- ret = bluetooth_gatt_unregister_application();
+ g_object_unref(manager_gproxy);
+ manager_gproxy = NULL;
- if (ret == BLUETOOTH_ERROR_NONE) {
- g_free(app_path);
- app_path = NULL;
- }
+ __bt_gatt_close_gdbus_connection();
return ret;
}
+ __bt_gatt_close_gdbus_connection();
+
return BLUETOOTH_ERROR_NOT_FOUND;
}
char_info->char_id = object_id;
char_info->char_uuid = g_strdup(char_uuid);
- for (i = 0; i < flag_count; i++) {
+ for (i = 0; i < flag_count; i++)
char_info->char_flags[i] = char_flags[i];
- }
+
char_info->flags_length = flag_count;
builder2 = g_variant_builder_new(G_VARIANT_TYPE("as"));
- for (i = 0; i < flag_count; i++) {
+ for (i = 0; i < flag_count; i++)
g_variant_builder_add(builder2, "s", char_flags[i]);
- }
flags_val = g_variant_new("as", builder2);
g_variant_builder_add(inner_builder, "{sv}", "Flags",
builder1 = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
- for (i = 0; i < value_length; i++) {
+ for (i = 0; i < value_length; i++)
g_variant_builder_add(builder1, "y", char_value[i]);
- }
char_val = g_variant_new("ay", builder1);
g_variant_builder_add(inner_builder, "{sv}", "Value", char_val);
char_info = __bt_gatt_find_gatt_char_info(serv_path, char_path);
if (char_info == NULL) {
g_strfreev(line_argv);
+ g_free(serv_path);
return BLUETOOTH_ERROR_INVALID_PARAM;
}
if (node_info == NULL) {
g_strfreev(line_argv);
+ g_free(serv_path);
return BLUETOOTH_ERROR_INTERNAL;
}
g_error_free(error);
g_free(path);
g_strfreev(line_argv);
+ g_free(serv_path);
return BLUETOOTH_ERROR_INTERNAL;
}
desc_info->desc_id = object_id;
desc_info->desc_uuid = g_strdup(desc_uuid);
- for (i = 0; i < flag_count; i++) {
+ for (i = 0; i < flag_count; i++)
desc_info->desc_flags[i] = desc_flags[i];
- }
desc_info->flags_length = flag_count;
builder2 = g_variant_builder_new(G_VARIANT_TYPE("as"));
- for (i = 0; i < flag_count; i++) {
+ for (i = 0; i < flag_count; i++)
g_variant_builder_add(builder2, "s", desc_flags[i]);
- }
flags_val = g_variant_new("as", builder2);
g_variant_builder_add(inner_builder, "{sv}", "Flags",
*desc_path = g_strdup(path);
g_free(path);
+ g_free(serv_path);
g_strfreev(line_argv);
g_variant_builder_unref(inner_builder);
g_variant_builder_unref(builder);
builder1 = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
- for (i = 0; i < value_length; i++) {
+ for (i = 0; i < value_length; i++)
g_variant_builder_add(builder1, "y", desc_value[i]);
- }
+
desc_val = g_variant_new("ay", builder1);
g_variant_builder_add(inner_builder, "{sv}", "Value", desc_val);
{
GDBusProxy *proxy = NULL;
- if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_GATT_REGISTER_APPLICATION)
- == BLUETOOTH_ERROR_PERMISSION_DEINED) {
- BT_ERR("Don't have aprivilege to use this API");
- return BLUETOOTH_ERROR_PERMISSION_DEINED;
- }
+ if (!is_server_started) {
- proxy = __bt_gatt_gdbus_get_manager_proxy("org.bluez",
- "/org/bluez/hci0", GATT_MNGR_INTERFACE);
- if (proxy == NULL || app_path == NULL)
- return BLUETOOTH_ERROR_INTERNAL;
+ if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_GATT_REGISTER_APPLICATION)
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have aprivilege to use this API");
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ }
- BT_INFO("RegisterApplication");
+ proxy = __bt_gatt_gdbus_get_manager_proxy("org.bluez",
+ "/org/bluez/hci0", GATT_MNGR_INTERFACE);
+ if (proxy == NULL || app_path == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
- g_dbus_proxy_call(proxy,
- "RegisterApplication",
- g_variant_new("(oa{sv})",
- app_path, NULL),
- G_DBUS_CALL_FLAGS_NONE, -1,
- NULL,
- (GAsyncReadyCallback) register_application_cb,
- NULL);
+ BT_INFO("RegisterApplication");
+
+ g_dbus_proxy_call(proxy,
+ "RegisterApplication",
+ g_variant_new("(oa{sv})",
+ app_path, NULL),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL,
+ (GAsyncReadyCallback) register_application_cb,
+ NULL);
+
+ is_server_started = true;
+
+ return BLUETOOTH_ERROR_NONE;
+ }
+
+ BT_INFO("Already RegisterApplication");
return BLUETOOTH_ERROR_NONE;
}
if (!__bt_gatt_get_service_state(serv_path)) {
BT_DBG("service not registered for this characteristic \n");
+ g_free(serv_path);
g_strfreev(line_argv);
return BLUETOOTH_ERROR_INTERNAL;
}
invalidated_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
inner_builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
- for (i = 0; i < value_length; i++) {
+ for (i = 0; i < value_length; i++)
g_variant_builder_add(inner_builder, "y", char_value[i]);
- }
update_value = g_variant_new("ay", inner_builder);
char_info = __bt_gatt_find_gatt_char_info(serv_path, char_path);
if (char_info == NULL) {
+ g_free(serv_path);
+ g_strfreev(line_argv);
+ g_variant_builder_unref(inner_builder);
+ g_variant_builder_unref(outer_builder);
+ g_variant_builder_unref(invalidated_builder);
+
return BLUETOOTH_ERROR_INVALID_DATA;
}
char_info->char_value = (char *)realloc(char_info->char_value, value_length);
if (char_info->char_value) {
- for (i = 0; i < value_length; i++) {
+ for (i = 0; i < value_length; i++)
char_info->char_value[i] = char_value[i];
- }
}
}
+ g_free(serv_path);
g_strfreev(line_argv);
g_variant_builder_unref(inner_builder);
g_variant_builder_unref(outer_builder);
return err;
}
+static void __bt_gatt_free_descriptor_info(struct gatt_desc_info *desc_info)
+{
+ int i;
+
+ if (!desc_info)
+ return;
+
+ g_free(desc_info->desc_path);
+ g_free(desc_info->desc_uuid);
+ g_free(desc_info->desc_value);
+
+ for (i = 0; i < desc_info->flags_length; i++)
+ g_free(desc_info->desc_flags[i]);
+
+ g_free(desc_info);
+}
+
+static void __bt_gatt_free_characteristic_info(struct gatt_char_info *char_info)
+{
+ int i;
+
+ if (!char_info)
+ return;
+
+ g_free(char_info->char_path);
+ g_free(char_info->char_uuid);
+ g_free(char_info->char_value);
+
+ for (i = 0; i < char_info->flags_length; i++)
+ g_free(char_info->char_flags[i]);
+
+ g_free(char_info);
+}
+
+static void __bt_gatt_free_service_info(struct gatt_service_info *svc_info)
+{
+ if (!svc_info)
+ return;
+
+ g_free(svc_info->serv_path);
+ g_free(svc_info->service_uuid);
+ g_free(svc_info);
+}
+
BT_EXPORT_API int bluetooth_gatt_unregister_service(const char *svc_path)
{
GSList *l, *l1;
struct gatt_service_info *svc_info;
gboolean ret;
int err = BLUETOOTH_ERROR_NONE;
- GSList *tmp;
BT_DBG("svc_path %s", svc_path);
svc_info = __bt_gatt_find_gatt_service_info(svc_path);
for (l = svc_info->char_data; l != NULL; l = l->next) {
struct gatt_char_info *char_info = l->data;
+ if (char_info == NULL)
+ break;
+
for (l1 = char_info->desc_data; l1 != NULL; l1 = l1->next) {
struct gatt_desc_info *desc_info = l1->data;
+ if (desc_info == NULL)
+ break;
+
ret = g_dbus_connection_unregister_object(g_conn,
desc_info->desc_id);
if (ret) {
} else {
err = BLUETOOTH_ERROR_INTERNAL;
}
+
+ /* list remove & free */
+ char_info->desc_data = g_slist_remove(char_info->desc_data, desc_info);
+ __bt_gatt_free_descriptor_info(desc_info);
}
+
+ g_slist_free(char_info->desc_data);
+ char_info->desc_data = NULL;
+
ret = g_dbus_connection_unregister_object(g_conn,
char_info->char_id);
if (ret) {
} else {
err = BLUETOOTH_ERROR_INTERNAL;
}
+
+ /* list remove & free */
+ svc_info->char_data = g_slist_remove(svc_info->char_data, char_info);
+ __bt_gatt_free_characteristic_info(char_info);
}
+
+ g_slist_free(svc_info->char_data);
+ svc_info->char_data = NULL;
+
ret = g_dbus_connection_unregister_object(g_conn, svc_info->serv_id);
if (ret) {
__bt_gatt_emit_interface_removed(svc_info->serv_path,
}
ret = g_dbus_connection_unregister_object(g_conn, svc_info->prop_id);
- if (ret) {
+ if (ret)
BT_DBG("Unregistered the service on properties interface");
- }
-
- for (tmp = gatt_services; tmp != NULL; tmp = tmp->next) {
- struct gatt_service_info *info = tmp->data;
- if (g_strcmp0(info->serv_path, svc_path) == 0) {
- gatt_services = g_slist_delete_link(gatt_services, tmp->data);
- }
- }
+ /* list remove & free */
+ gatt_services = g_slist_remove(gatt_services, svc_info);
+ __bt_gatt_free_service_info(svc_info);
new_service = FALSE;
- if (gatt_services->next == NULL)
+ if (gatt_services == NULL)
+ serv_id = 1;
+ else if (gatt_services->next == NULL)
serv_id--;
return err;
if (req_info) {
if (resp_state != BLUETOOTH_ERROR_NONE) {
-
- GQuark quark = g_quark_from_string("gatt-server");
- GError *err = g_error_new(quark, 0, "Application Error");
- g_dbus_method_invocation_return_gerror(req_info->context, err);
- g_error_free(err);
+ g_dbus_method_invocation_return_dbus_error(req_info->context,
+ "org.bluez.Error.Failed", "Application Error");
gatt_requests = g_slist_remove(gatt_requests, req_info);
if (!__bt_gatt_get_service_state(serv_path)) {
BT_DBG("service not registered for this characteristic \n");
+ g_free(serv_path);
g_strfreev(line_argv);
return BLUETOOTH_ERROR_INTERNAL;
}
+ g_free(serv_path);
+
outer_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
invalidated_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
#include "bt-event-handler.h"
#define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
+#define HID_DEVICE_UUID "00001124-0000-1000-8000-00805f9b43bf"
#define REPORTID_MOUSE 1
#define BT_HID_BUFFER_LEN 100
-/* The types of HIDP transaction */
-#define BT_HIDP_TRANSACTION_SET_PROTOCOL 0x70
-#define BT_HIDP_TRANSACTION_GET_IDLE 0x80
-#define BT_HIDP_TRANSACTION_SET_IDLE 0x90
-#define BT_HIDP_TRANSACTION_DATA 0xa0
-#define BT_HIDP_TRANSACTION_DATC 0xb0
-#define BT_HIDP_TRANSACTION_HANDSHAKE 0x00
-#define BT_HIDP_TRANSACTION_HID_CONTROL 0x10
-#define BT_HIDP_TRANSACTION_GET_REPORT 0x40
-#define BT_HIDP_TRANSACTION_SET_REPORT 0x50
-#define BT_HIDP_TRANSACTION_GET_PROTOCOL 0x60
-
-#define BT_HIDP_DATA_OUT_RTYPE 0x02
-#define BT_HIDP_DATA_IN_RTYPE 0x01
-
-#define BT_HIDP_HSHK_ERROR_UNSUPPORTED_REQUEST 0x03
-#define BT_HIDP_HSHK_ERROR_INVALID_PARAM 0x04
-#define BT_HIDP_HSHK_ERROR_UNKNOWN 0x0E
-#define BT_HIDP_HSHK_ERROR_FATAL 0x0F
-#define BT_HIDP_HSHK_OK_SUCCESSFUL 0x00
-#define BT_HIDP_HSHK_NOT_AVAILABLE 0x01
-#define BT_HIDP_HSHK_ERROR_INVALID_REPORT_ID 0x02
-
-/* The masks of BT_HIDP header */
-#define BT_HIDP_HEADER_PARAMETER_MASK 0x0f
-#define BT_HIDP_HEADER_TRANSACTION_MASK 0xf0
+/* HIDP header masks */
+#define BT_HID_HEADER_TRANS_MASK 0xf0
+#define BT_HID_HEADER_PARAM_MASK 0x0f
+
+/* HIDP transaction types */
+#define BT_HID_TRANS_HANDSHAKE 0x00
+#define BT_HID_TRANS_HID_CONTROL 0x10
+#define BT_HID_TRANS_GET_REPORT 0x40
+#define BT_HID_TRANS_SET_REPORT 0x50
+#define BT_HID_TRANS_GET_PROTOCOL 0x60
+#define BT_HID_TRANS_SET_PROTOCOL 0x70
+#define BT_HID_TRANS_GET_IDLE 0x80
+#define BT_HID_TRANS_SET_IDLE 0x90
+#define BT_HID_TRANS_DATA 0xa0
+#define BT_HID_TRANS_DATC 0xb0
+
+#define BT_HID_DATA_RTYPE_INPUT 0x01
+#define BT_HID_DATA_RTYPE_OUTPUT 0x02
+
+#define BT_HID_HSHK_SUCCESSFUL 0x00
+#define BT_HID_HSHK_NOT_READY 0x01
+#define BT_HID_HSHK_ERR_INVALID_REPORT_ID 0x02
+#define BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST 0x03
+#define BT_HID_HSHK_ERR_INVALID_PARAMETER 0x04
+#define BT_HID_HSHK_ERR_UNKNOWN 0x0E
+#define BT_HID_HSHK_ERR_FATAL 0x0F
typedef struct {
guint object_id;
static gboolean __hid_disconnect(hid_connected_device_info_t *info);
+int _bt_hid_device_get_fd(const char *address, int *ctrl, int *intr)
+{
+
+ int ret = BLUETOOTH_ERROR_NONE;
+ char *adapter_path;
+ GVariant *result = NULL;
+ GError *err = NULL;
+ GDBusConnection *conn;
+ GDBusProxy *server_proxy;
+ int index1 = 0;
+ int index2 = 0;
+ GUnixFDList *out_fd_list = NULL;
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ adapter_path = _bt_get_device_object_path((char *)address);
+ retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+ BT_INFO_C("Device : %s", adapter_path);
+ server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ adapter_path, "org.bluez.Input1", NULL, NULL);
+ g_free(adapter_path);
+
+ if (server_proxy == NULL) {
+ BT_ERR("Failed to get the network server proxy\n");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ result = g_dbus_proxy_call_with_unix_fd_list_sync(server_proxy, "GetFD",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &out_fd_list,
+ NULL,
+ &err);
+ if (result == NULL) {
+ if (err != NULL) {
+ g_dbus_error_strip_remote_error(err);
+ BT_ERR("INPUT server register Error: %s\n", err->message);
+ if (g_strcmp0(err->message, "Already Exists") == 0)
+ ret = BLUETOOTH_ERROR_ALREADY_INITIALIZED;
+ else
+ ret = BLUETOOTH_ERROR_INTERNAL;
+
+ g_error_free(err);
+ }
+ } else {
+ g_variant_get(result, "(hh)", &index1, &index2);
+ int fd1 = g_unix_fd_list_get(out_fd_list, index1, NULL);
+ int fd2 = g_unix_fd_list_get(out_fd_list, index2, NULL);
+
+ *ctrl = fd1;
+ *intr = fd2;
+ g_object_unref(out_fd_list);
+ g_variant_unref(result);
+ }
+ g_object_unref(server_proxy);
+ return ret;
+}
+
static hid_connected_device_info_t *__find_hid_info_with_address(const char *remote_addr)
{
GSList *l;
}
static void __hid_connected_cb(hid_connected_device_info_t *info,
- bt_event_info_t *event_info)
+ int result)
{
bluetooth_hid_request_t conn_info;
+ bt_event_info_t *event_info = NULL;
+
+ event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
+ if (event_info == NULL)
+ return;
memset(&conn_info, 0x00, sizeof(bluetooth_hid_request_t));
if (info->intr_fd != -1 && info->ctrl_fd == -1)
conn_info.socket_fd = info->ctrl_fd;
_bt_convert_addr_string_to_type(conn_info.device_addr.addr, info->address);
- BT_INFO_C("Connected [HID Device]");
+ if (result == BLUETOOTH_ERROR_NONE)
+ BT_INFO_C("Connected [HID Device]");
+
_bt_common_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
- BLUETOOTH_ERROR_NONE, &conn_info,
+ result, &conn_info,
event_info->cb, event_info->user_data);
}
+static void __hid_connect_response_cb(GDBusProxy *proxy, GAsyncResult *res,
+ gpointer user_data)
+
+{
+ int result;
+ GError *error = NULL;
+ GVariant *ret = NULL;
+ hid_connected_device_info_t info;
+ const char *path;
+
+ BT_DBG("+");
+
+ ret = g_dbus_proxy_call_finish(proxy, res, &error);
+ if (ret == NULL) {
+ g_dbus_error_strip_remote_error(error);
+ BT_ERR("Error : %s \n", error->message);
+
+ if (g_strcmp0(error->message, "In Progress") == 0)
+ result = BLUETOOTH_ERROR_DEVICE_BUSY;
+ else
+ result = BLUETOOTH_ERROR_INTERNAL;
+
+ info.ctrl_fd = -1;
+ info.intr_fd = -1;
+
+ info.address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+
+ path = g_dbus_proxy_get_object_path(proxy);
+ _bt_convert_device_path_to_address(path, info.address);
+
+ __hid_connected_cb(&info, result);
+
+ g_free(info.address);
+
+ g_error_free(error);
+ } else {
+ g_variant_unref(ret);
+ }
+
+ if (proxy)
+ g_object_unref(proxy);
+
+ BT_DBG("-");
+}
+
static gboolean __hid_disconnect(hid_connected_device_info_t *info)
{
bluetooth_hid_request_t disconn_info;
info->intr_data_id = 0;
}
- if (info->intr_fd >= 0) {
- close(info->ctrl_fd);
- close(info->intr_fd);
- info->intr_fd = -1;
- info->ctrl_fd = -1;
- }
-
if (info->ctrl_data_io) {
g_io_channel_shutdown(info->ctrl_data_io, TRUE, NULL);
g_io_channel_unref(info->ctrl_data_io);
g_io_channel_unref(info->intr_data_io);
info->intr_data_io = NULL;
}
+ if (info->intr_fd >= 0) {
+ close(info->ctrl_fd);
+ close(info->intr_fd);
+ info->intr_fd = -1;
+ info->ctrl_fd = -1;
+ }
info->disconnect_idle_id = 0;
event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
if (event_info == NULL)
memset(&disconn_info, 0x00, sizeof(bluetooth_hid_request_t));
disconn_info.socket_fd = fd;
- _bt_convert_addr_string_to_type(disconn_info.device_addr.addr, info->address);
+ _bt_convert_addr_string_to_type(disconn_info.device_addr.addr , info->address);
_bt_common_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
BLUETOOTH_ERROR_NONE, &disconn_info,
event_info->cb, event_info->user_data);
g_free(info);
}
+static gboolean __is_error_by_disconnect(GError *err)
+{
+ return !g_strcmp0(err->message, "Connection reset by peer") ||
+ !g_strcmp0(err->message, "Connection timed out") ||
+ !g_strcmp0(err->message, "Software caused connection abort");
+}
+
static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
gpointer data)
{
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
BT_ERR_C("HID disconnected: %d", info->ctrl_fd);
- if (info->disconnect_idle_id > 0) {
- BT_INFO("Disconnect idle still not process remove source");
- g_source_remove(info->disconnect_idle_id);
- info->disconnect_idle_id = 0;
- }
+ if (info->disconnect_idle_id > 0) {
+ BT_INFO("Disconnect idle still not process remove source");
+ g_source_remove(info->disconnect_idle_id);
+ info->disconnect_idle_id = 0;
+ }
__hid_disconnect(info);
return FALSE;
}
+
status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
&len, &err);
if (status == G_IO_STATUS_NORMAL) {
BT_INFO("Parsing Data");
bluetooth_hid_received_data_t data = {0};
header = buffer[0];
- type = header & BT_HIDP_HEADER_TRANSACTION_MASK;
- param = header & BT_HIDP_HEADER_PARAMETER_MASK;
+ type = header & BT_HID_HEADER_TRANS_MASK;
+ param = header & BT_HID_HEADER_PARAM_MASK;
BT_INFO("type %d , param %d", type, param);
BT_INFO("Data Reveived from %s" , info->address);
+
+ event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
+ if (event_info == NULL)
+ return FALSE;
+
data.address = g_strdup(info->address);
switch (type) {
- case BT_HIDP_TRANSACTION_HANDSHAKE:
- BT_INFO("TRANS HANDSHAKE");
- data.type = HTYPE_TRANS_HANDSHAKE;
- data.buffer_size = len;
- data.buffer = (char *) malloc(sizeof(char) * len);
- if (data.buffer)
- memcpy(data.buffer, buffer, len);
- break;
- case BT_HIDP_TRANSACTION_HID_CONTROL:
- BT_INFO("HID CONTROL");
- data.type = HTYPE_TRANS_HID_CONTROL;
- data.buffer_size = len;
- data.buffer = (char *) malloc(sizeof(char) * len);
- if (data.buffer)
- memcpy(data.buffer, buffer, len);
- break;
- case BT_HIDP_TRANSACTION_DATA:
- BT_INFO("TRANS DATA");
- data.type = HTYPE_TRANS_DATA;
- if (param & BT_HIDP_DATA_IN_RTYPE) {
- BT_INFO("Input Report");
- data.param = PTYPE_DATA_RTYPE_INPUT;
- data.buffer_size = len;
- data.buffer = (char *) malloc(sizeof(char) * len);
- if (data.buffer)
- memcpy(data.buffer, buffer, len);
- } else {
- BT_INFO("Out Report");
- data.param = PTYPE_DATA_RTYPE_OUTPUT;
- data.buffer_size = len;
- data.buffer = (char *) malloc(sizeof(char) * len);
- if (data.buffer)
- memcpy(data.buffer, buffer, len);
- }
- break;
- case BT_HIDP_TRANSACTION_GET_REPORT: {
- BT_INFO("Get Report");
- data.type = HTYPE_TRANS_GET_REPORT;
- if (param & BT_HIDP_DATA_IN_RTYPE) {
- BT_INFO("Input Report");
- data.param = PTYPE_DATA_RTYPE_INPUT;
- } else {
- BT_INFO("Output Report");
- data.param = PTYPE_DATA_RTYPE_OUTPUT;
- }
+ case BT_HID_TRANS_HANDSHAKE:
+ BT_INFO("TRANS HANDSHAKE");
+ data.type = HTYPE_TRANS_HANDSHAKE;
+ data.buffer_size = len;
+ data.buffer = (char *) malloc(sizeof(char) * len);
+ if (data.buffer)
+ memcpy(data.buffer, buffer, len);
+ break;
+
+ case BT_HID_TRANS_HID_CONTROL:
+ BT_INFO("HID CONTROL");
+ data.type = HTYPE_TRANS_HID_CONTROL;
+ data.buffer_size = len;
+ data.buffer = (char *) malloc(sizeof(char) * len);
+ if (data.buffer)
+ memcpy(data.buffer, buffer, len);
+ break;
+
+ case BT_HID_TRANS_DATA:
+ BT_INFO("TRANS DATA");
+ data.type = HTYPE_TRANS_DATA;
+ if (param & BT_HID_DATA_RTYPE_INPUT) {
+ BT_INFO("Input Report");
+ data.param = PTYPE_DATA_RTYPE_INPUT;
data.buffer_size = len;
data.buffer = (char *) malloc(sizeof(char) * len);
if (data.buffer)
memcpy(data.buffer, buffer, len);
- break;
- }
- case BT_HIDP_TRANSACTION_SET_REPORT: {
- BT_INFO("Set Report");
- data.type = HTYPE_TRANS_SET_REPORT;
- if (param & BT_HIDP_DATA_IN_RTYPE) {
- BT_INFO("Input Report");
- data.param = PTYPE_DATA_RTYPE_INPUT;
- } else {
- BT_INFO("Output Report");
- data.param = PTYPE_DATA_RTYPE_OUTPUT;
- }
+ } else {
+ BT_INFO("Out Report");
+ data.param = PTYPE_DATA_RTYPE_OUTPUT;
data.buffer_size = len;
data.buffer = (char *) malloc(sizeof(char) * len);
if (data.buffer)
memcpy(data.buffer, buffer, len);
- break;
}
- case BT_HIDP_TRANSACTION_GET_PROTOCOL:{
- BT_INFO("Get_PROTOCOL");
- data.type = HTYPE_TRANS_GET_PROTOCOL;
+ break;
+
+ case BT_HID_TRANS_GET_REPORT: {
+ BT_INFO("Get Report");
+ data.type = HTYPE_TRANS_GET_REPORT;
+ if (param & BT_HID_DATA_RTYPE_INPUT) {
+ BT_INFO("Input Report");
data.param = PTYPE_DATA_RTYPE_INPUT;
- data.buffer_size = len;
- data.buffer = (char *) malloc(sizeof(char) * len);
- if (data.buffer)
- memcpy(data.buffer, buffer, len);
- break;
+ } else {
+ BT_INFO("Output Report");
+ data.param = PTYPE_DATA_RTYPE_OUTPUT;
}
- case BT_HIDP_TRANSACTION_SET_PROTOCOL:{
- BT_INFO("Set_PROTOCOL");
- data.type = HTYPE_TRANS_SET_PROTOCOL;
+ data.buffer_size = len;
+ data.buffer = (char *) malloc(sizeof(char) * len);
+ if (data.buffer)
+ memcpy(data.buffer, buffer, len);
+ break;
+ }
+
+ case BT_HID_TRANS_SET_REPORT: {
+ BT_INFO("Set Report");
+ data.type = HTYPE_TRANS_SET_REPORT;
+ if (param & BT_HID_DATA_RTYPE_INPUT) {
+ BT_INFO("Input Report");
data.param = PTYPE_DATA_RTYPE_INPUT;
- data.buffer_size = len;
- data.buffer = (char *) malloc(sizeof(char) * len);
- if (data.buffer)
- memcpy(data.buffer, buffer, len);
- break;
- }
- default: {
- BT_INFO("unsupported HIDP control message");
- BT_ERR("Send Handshake Message");
- guint8 type = BT_HIDP_TRANSACTION_HANDSHAKE |
- BT_HIDP_HSHK_ERROR_UNSUPPORTED_REQUEST;
- data.type = HTYPE_TRANS_UNKNOWN;
- int fd = g_io_channel_unix_get_fd(chan);
- int bytes = write(fd, &type, sizeof(type));
- BT_INFO("Bytes Written %d", bytes);
- break;
+ } else {
+ BT_INFO("Output Report");
+ data.param = PTYPE_DATA_RTYPE_OUTPUT;
}
+ data.buffer_size = len;
+ data.buffer = (char *) malloc(sizeof(char) * len);
+ if (data.buffer)
+ memcpy(data.buffer, buffer, len);
+ break;
}
- event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
- if (event_info == NULL) {
- g_free(data.buffer);
- g_free((char *)data.address);
- return FALSE;
+
+ case BT_HID_TRANS_GET_PROTOCOL:{
+ BT_INFO("Get_PROTOCOL");
+ data.type = HTYPE_TRANS_GET_PROTOCOL;
+ data.param = PTYPE_DATA_RTYPE_INPUT;
+ data.buffer_size = len;
+ data.buffer = (char *) malloc(sizeof(char) * len);
+ if (data.buffer)
+ memcpy(data.buffer, buffer, len);
+ break;
}
- _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
+ case BT_HID_TRANS_SET_PROTOCOL:{
+ BT_INFO("Set_PROTOCOL");
+ data.type = HTYPE_TRANS_SET_PROTOCOL;
+ data.param = PTYPE_DATA_RTYPE_INPUT;
+ data.buffer_size = len;
+ data.buffer = (char *) malloc(sizeof(char) * len);
+ if (data.buffer)
+ memcpy(data.buffer, buffer, len);
+ break;
+ }
+
+ default: {
+ BT_INFO("unsupported HIDP control message");
+ BT_ERR("Send Handshake Message");
+ guint8 type = 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));
+ BT_INFO("Bytes Written %d", bytes);
+ break;
+ }
+ }
+
+ _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
BLUETOOTH_ERROR_NONE, &data,
event_info->cb, event_info->user_data);
-
+ if (data.buffer)
g_free(data.buffer);
+
+ if (data.address)
g_free((char *)data.address);
} else {
- BT_INFO("Error while reading data");
+ BT_ERR("Error while reading data %d [%s]", status, info->address);
+ if (err) {
+ BT_ERR("IO Channel read error [%s]", err->message);
+ if (status == G_IO_STATUS_ERROR &&
+ __is_error_by_disconnect(err)) {
+ BT_DBG("cond : %d", cond);
+ g_error_free(err);
+ __hid_disconnect(info);
+ return FALSE;
+ }
+ g_error_free(err);
+ } else if (status == G_IO_STATUS_EOF) {
+ __hid_disconnect(info);
+ return FALSE;
+ }
}
return TRUE;
}
{
hid_info_t *info = NULL;
hid_connected_device_info_t *dev_info = NULL;
- bt_event_info_t *event_info = NULL;
char address[18];
info = hid_info;
dev_info->intr_data_io = g_io_channel_unix_new(dev_info->intr_fd);
g_io_channel_set_encoding(dev_info->intr_data_io, NULL, NULL);
g_io_channel_set_flags(dev_info->intr_data_io, G_IO_FLAG_NONBLOCK, NULL);
-
+ g_io_channel_set_close_on_unref(dev_info->intr_data_io, TRUE);
dev_info->intr_data_id = g_io_add_watch(dev_info->intr_data_io,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
__received_cb, dev_info);
dev_info->ctrl_data_io = g_io_channel_unix_new(dev_info->ctrl_fd);
g_io_channel_set_encoding(dev_info->ctrl_data_io, NULL, NULL);
g_io_channel_set_flags(dev_info->ctrl_data_io, G_IO_FLAG_NONBLOCK, NULL);
-
+ g_io_channel_set_close_on_unref(dev_info->ctrl_data_io, TRUE);
dev_info->ctrl_data_id = g_io_add_watch(dev_info->ctrl_data_io,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
__received_cb, dev_info);
}
- if (dev_info->ctrl_fd != -1 && dev_info->intr_fd != -1) {
- event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
- if (event_info)
- __hid_connected_cb(dev_info, event_info);
- }
+
+ if (dev_info->ctrl_fd != -1 && dev_info->intr_fd != -1)
+ __hid_connected_cb(dev_info, BLUETOOTH_ERROR_NONE);
return 0;
}
path = g_strdup_printf("/org/socket/server/%d", getpid());
object_id = _bt_register_new_conn(path, new_hid_connection);
- if (object_id < 0) {
+ if (object_id < 0)
return NULL;
- }
+
info = g_new(hid_info_t, 1);
info->object_id = (guint)object_id;
info->path = path;
return info;
}
+void _bluetooth_hid_free_hid_info(void)
+{
+ if (hid_info == NULL) {
+ BT_DBG("hid_info is already NULL");
+ return;
+ }
+
+ __free_hid_info(hid_info);
+ hid_info = NULL;
+}
+
BT_EXPORT_API int bluetooth_hid_device_init(hid_cb_func_ptr callback_ptr, void *user_data)
{
int ret;
if (hid_info == NULL)
return BLUETOOTH_ERROR_INTERNAL;
- hid_info->uuid = g_strdup(HID_UUID);
+ hid_info->uuid = g_strdup(HID_DEVICE_UUID);
profile_info.authentication = TRUE;
profile_info.authorization = TRUE;
profile_info.uuid = hid_info->uuid;
BT_INFO("uuid %s", profile_info.uuid);
- result = _bt_register_profile_platform(&profile_info, FALSE);
+ result = _bt_register_profile(&profile_info, FALSE);
return result;
}
_bt_unregister_profile(hid_info->path);
- __free_hid_info(hid_info);
- hid_info = NULL;
+ _bluetooth_hid_free_hid_info();
+
return BLUETOOTH_ERROR_NONE;
}
}
memcpy(device_address, remote_addr, BT_ADDRESS_STRING_SIZE);
- ret = _bt_connect_profile(device_address, HID_UUID, NULL, NULL);
+ ret = _bt_connect_profile(device_address, HID_DEVICE_UUID,
+ __hid_connect_response_cb, NULL);
return ret;
}
BT_EXPORT_API int bluetooth_hid_device_disconnect(const char *remote_addr)
{
+ BT_CHECK_PARAMETER(remote_addr, return);
+
if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DISCONNECT)
== BLUETOOTH_ERROR_PERMISSION_DEINED) {
BT_ERR("Don't have a privilege to use this API");
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
+
hid_connected_device_info_t *info = NULL;
info = __find_hid_info_with_address(remote_addr);
if (info == NULL)
return BLUETOOTH_ERROR_INVALID_PARAM;
- _bt_disconnect_profile((char *)remote_addr, HID_UUID, NULL, NULL);
+ _bt_disconnect_profile((char *)remote_addr, HID_DEVICE_UUID, NULL, NULL);
info->disconnect_idle_id = g_idle_add((GSourceFunc)__hid_disconnect, info);
{
int result;
int written = 0;
- int socket_fd;
hid_connected_device_info_t *info = NULL;
+ BT_CHECK_PARAMETER(remote_addr, return);
+
switch (privilege_token_send_mouse) {
case 0:
- result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_HID_DEVICE_SEND_MOUSE_EVENT);
+ result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_MOUSE_EVENT);
if (result == BLUETOOTH_ERROR_NONE) {
privilege_token_send_mouse = 1; /* Have a permission */
BT_ERR("Connection Information not found");
return BLUETOOTH_ERROR_INVALID_PARAM;
}
+ int socket_fd;
if (info->intr_fd != -1 && info->ctrl_fd == -1)
socket_fd = info->intr_fd;
{
int result;
int written = 0;
- int socket_fd;
hid_connected_device_info_t *info = NULL;
+ BT_CHECK_PARAMETER(remote_addr, return);
+
switch (privilege_token_send_key) {
case 0:
- result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_HID_DEVICE_SEND_KEY_EVENT);
+ result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_KEY_EVENT);
if (result == BLUETOOTH_ERROR_NONE) {
privilege_token_send_key = 1; /* Have a permission */
return BLUETOOTH_ERROR_INVALID_PARAM;
}
+ int socket_fd;
+
if (info->intr_fd != -1 && info->ctrl_fd == -1)
socket_fd = info->intr_fd;
else
return written;
}
+BT_EXPORT_API int bluetooth_hid_device_send_custom_event(const char *remote_addr,
+ unsigned char btcode, unsigned char report_id,
+ const char *data, unsigned int data_len)
+{
+ int result;
+ int written = 0;
+ int socket_fd;
+ hid_connected_device_info_t *info = NULL;
+ char *send_event = NULL;
+
+ BT_CHECK_PARAMETER(remote_addr, return);
+ BT_CHECK_PARAMETER(data, return);
+
+ switch (privilege_token_send_key) {
+ case 0:
+ result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_CUSTOM_EVENT);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ privilege_token_send_key = 1; /* Have a permission */
+ } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ BT_ERR("Don't have a privilege to use this API");
+ privilege_token_send_key = -1; /* Don't have a permission */
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ } else {
+ /* Just break - It is not related with permission error */
+ }
+ break;
+ case 1:
+ /* Already have a privilege */
+ break;
+ case -1:
+ return BLUETOOTH_ERROR_PERMISSION_DEINED;
+ default:
+ /* Invalid privilge token value */
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ info = __find_hid_info_with_address(remote_addr);
+ if (info == NULL) {
+ BT_ERR("Connection Information not found");
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+ }
+
+ if (info->intr_fd != -1 && info->ctrl_fd == -1)
+ socket_fd = info->intr_fd;
+ else
+ socket_fd = info->ctrl_fd;
+
+ send_event = (char*)g_malloc0(data_len + 2);
+ if (send_event == NULL)
+ return BLUETOOTH_ERROR_OUT_OF_MEMORY;
+
+ send_event[0] = (char)btcode;
+ send_event[1] = (char)report_id;
+ memcpy(send_event + 2, data, data_len);
+
+ written = write(socket_fd, send_event, data_len + 2);
+
+ g_free(send_event);
+
+ return written;
+}
+
BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
- bluetooth_hid_header_type_t htype,
- bluetooth_hid_param_type_t ptype,
+ bt_hid_header_type_t htype,
+ bt_hid_param_type_t ptype,
const char *data,
unsigned int data_len)
{
return BLUETOOTH_ERROR_INVALID_PARAM;
}
+ BT_CHECK_PARAMETER(remote_addr, return);
+
switch (privilege_token_reply) {
case 0:
- result = _bt_check_privilege(BT_BLUEZ_SERVICE, BT_HID_DEVICE_SEND_REPLY_TO_REPORT);
+ result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_REPLY_TO_REPORT);
if (result == BLUETOOTH_ERROR_NONE) {
privilege_token_reply = 1; /* Have a permission */
BT_INFO("htype %d ptype %d", htype, ptype);
switch (htype) {
- case HTYPE_TRANS_GET_REPORT: {
- switch (ptype) {
- case PTYPE_DATA_RTYPE_INPUT: {
- output_report.type = BT_HIDP_TRANSACTION_DATA |
- BT_HIDP_DATA_IN_RTYPE;
- memcpy(output_report.rep_data, data, data_len);
- bytes = write(info->intr_fd, &output_report,
- sizeof(output_report));
- BT_DBG("Bytes Written %d", bytes);
- break;
- }
- default:
- BT_INFO("Not Supported");
- break;
- }
- break;
- case HTYPE_TRANS_GET_PROTOCOL: {
- BT_DBG("Replying to Get_PROTOCOL");
- output_report.type = BT_HIDP_TRANSACTION_DATA | BT_HIDP_DATA_OUT_RTYPE;
- output_report.rep_data[0] = data[0];
- bytes = write(info->intr_fd, &output_report, 2);
- BT_DBG("Bytes Written %d", bytes);
- break;
- }
- case HTYPE_TRANS_SET_PROTOCOL: {
- BT_DBG("Reply to Set_Protocol");
- output_report.type = BT_HIDP_TRANSACTION_DATA | BT_HIDP_DATA_IN_RTYPE;
+ case HTYPE_TRANS_GET_REPORT: {
+ switch (ptype) {
+ case PTYPE_DATA_RTYPE_INPUT: {
+ output_report.type = BT_HID_TRANS_DATA |
+ BT_HID_DATA_RTYPE_INPUT;
memcpy(output_report.rep_data, data, data_len);
- bytes = write(info->ctrl_fd, &output_report,
- sizeof(output_report));
+ bytes = write(info->intr_fd, &output_report,
+ sizeof(output_report));
BT_DBG("Bytes Written %d", bytes);
break;
}
- case HTYPE_TRANS_HANDSHAKE: {
- BT_DBG("Replying Handshake");
- output_report.type = BT_HIDP_TRANSACTION_HANDSHAKE | data[0];
- memset(output_report.rep_data, 0, sizeof(output_report.rep_data));
- bytes = write(info->intr_fd, &output_report.type,
- sizeof(output_report.type));
- BT_DBG("Bytes Written %d", bytes);
+ default:
+ BT_INFO("Not Supported");
break;
- }
- default:
- break;
+ }
+ break;
+
+ case HTYPE_TRANS_GET_PROTOCOL: {
+ BT_DBG("Replying to Get_PROTOCOL");
+ output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_OUTPUT;
+ output_report.rep_data[0] = data[0];
+ bytes = write(info->intr_fd, &output_report, 2);
+ BT_DBG("Bytes Written %d", bytes);
+ break;
+ }
+
+ case HTYPE_TRANS_SET_PROTOCOL: {
+ BT_DBG("Reply to Set_Protocol");
+ output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_INPUT;
+ memcpy(output_report.rep_data, data, data_len);
+ bytes = write(info->ctrl_fd, &output_report,
+ sizeof(output_report));
+ BT_DBG("Bytes Written %d", bytes);
+ break;
+ }
+
+ case HTYPE_TRANS_HANDSHAKE: {
+ BT_DBG("Replying Handshake");
+ output_report.type = BT_HID_TRANS_HANDSHAKE | data[0];
+ memset(output_report.rep_data, 0, sizeof(output_report.rep_data));
+ bytes = write(info->intr_fd, &output_report.type,
+ sizeof(output_report.type));
+ BT_DBG("Bytes Written %d", bytes);
+ break;
+ }
+ default:
+ break;
}
}
return bytes;
return result;
}
+BT_EXPORT_API int bluetooth_hid_enable_barcode_feature(void)
+{
+ int result;
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_HID_ENABLE_BARCODE_FEATURE,
+ 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;
+}
+
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-BT_EXPORT_API int bluetooth_le_ipsp_init(void)
+BT_EXPORT_API int bluetooth_ipsp_init(void)
{
int ret = IPSP_ERROR_NONE;
return ret;
}
-BT_EXPORT_API int bluetooth_le_ipsp_deinit(void)
+BT_EXPORT_API int bluetooth_ipsp_deinit(void)
{
int ret = IPSP_ERROR_NONE;
return ret;
}
-BT_EXPORT_API int bluetooth_le_ipsp_connect(const ipsp_device_address_t *device_address)
+BT_EXPORT_API int bluetooth_ipsp_connect(const ipsp_device_address_t *device_address)
{
int ret = IPSP_ERROR_NONE;
return ret;
}
-BT_EXPORT_API int bluetooth_le_ipsp_disconnect(const ipsp_device_address_t *device_address)
+BT_EXPORT_API int bluetooth_ipsp_disconnect(const ipsp_device_address_t *device_address)
{
int ret = IPSP_ERROR_NONE;
if (result == BLUETOOTH_ERROR_NONE) {
_bt_set_obex_server_id(BT_NATIVE_SERVER);
res = _bt_register_event(BT_OPP_SERVER_EVENT, user_info->cb,
- user_info->user_data);
+ user_info->user_data);
if (res != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to _bt_register_event(%d)", res);
} else {
if (result == BLUETOOTH_ERROR_NONE) {
_bt_set_obex_server_id(BT_CUSTOM_SERVER);
res = _bt_register_event(BT_OPP_SERVER_EVENT, user_info->cb,
- user_info->user_data);
+ user_info->user_data);
if (res != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to _bt_register_event(%d)", res);
result = _bt_send_request(BT_OBEX_SERVICE, BT_OBEX_SERVER_IS_ACTIVATED,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
is_activated = g_array_index(out_param, gboolean, 0);
- } else {
+ else
BT_ERR("Fail to send request");
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
result = _bt_send_request(BT_OBEX_SERVICE, BT_OBEX_SERVER_IS_RECEIVING,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*is_receiving = g_array_index(out_param, gboolean, 0);
- } else {
+ else
BT_ERR("Fail to send request");
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
result = _bt_send_request(BT_BLUEZ_SERVICE, BT_OOB_READ_LOCAL_DATA,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
- *local_oob_data = g_array_index(out_param,
- bt_oob_data_t, 0);
- }
+ if (result == BLUETOOTH_ERROR_NONE)
+ *local_oob_data = g_array_index(out_param, bt_oob_data_t, 0);
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
}
BT_EXPORT_API int bluetooth_opc_push_files(bluetooth_device_address_t *remote_address,
- char **file_name_array)
+ char **file_name_array)
{
int result;
int i;
result = _bt_send_request(BT_OBEX_SERVICE, BT_OPP_IS_PUSHING_FILES,
in_param1, in_param2, in_param3, in_param4, &out_param);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
*is_sending = g_array_index(out_param, gboolean, 0);
- } else {
+ else
BT_ERR("Fail to send request");
- }
+
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
+BT_EXPORT_API int bluetooth_opp_get_transfer_progress(bluetooth_opp_transfer_type_t transfer_type,
+ int transfer_id, unsigned char *progress)
+{
+ int result;
+ int direction = transfer_type;
+ int percentage = 0;
+ 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, &direction, sizeof(int));
+ g_array_append_vals(in_param2, &transfer_id, sizeof(int));
+
+ result = _bt_send_request(BT_OBEX_SERVICE, BT_OPP_GET_TRANSFER_PROGRESS,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ percentage = g_array_index(out_param, guint8, 0);
+ BT_DBG("Percentage: %d", percentage);
+ } else {
+ BT_ERR("Fail to send request");
+ }
+
+ if (progress)
+ *progress = percentage;
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
\ No newline at end of file
bt_user_info_t *user_info;
int ret;
- BT_CHECK_ENABLED(return);
if (is_pbap_initialized)
return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
BT_EXPORT_API int bluetooth_pbap_deinit(void)
{
int ret;
- BT_CHECK_ENABLED(return);
+
BT_CHECK_PBAP_INITIALIZED(return);
ret = _bt_unregister_event(BT_PBAP_CLIENT_EVENT);
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "bluetooth-api.h"
+#include "bt-internal-types.h"
+
+#include "bt-common.h"
+#include "bt-request-sender.h"
+#include "bt-event-handler.h"
+
+BT_EXPORT_API int bluetooth_set_proximity_property(const bluetooth_device_address_t *device_address,
+ bluetooth_pxp_poperty_t property, int value)
+{
+ int result = BLUETOOTH_ERROR_INTERNAL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ BT_DBG("");
+
+ g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &property, sizeof(int));
+ g_array_append_vals(in_param3, &value, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PXP_SET_PROPERTY,
+ 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_get_proximity_property(const bluetooth_device_address_t *device_address,
+ bluetooth_pxp_poperty_t property, int *value)
+{
+ int result = BLUETOOTH_ERROR_INTERNAL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ BT_DBG("");
+
+ g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
+ g_array_append_vals(in_param2, &property, sizeof(int));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PXP_GET_PROPERTY,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ if (out_param->len > 0) {
+ *value = g_array_index(out_param,
+ int, 0);
+ } else {
+ BT_ERR("out_param length is 0!!");
+ }
+ }
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_get_proximity_supported_services(const bluetooth_device_address_t *device_address,
+ int *services_supported)
+{
+ int result = BLUETOOTH_ERROR_INTERNAL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ BT_DBG("");
+
+ g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PXP_GET_SUPPORTED_SERIVCES,
+ in_param1, in_param2, in_param3, in_param4, &out_param);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ if (out_param->len > 0) {
+ *services_supported = g_array_index(out_param,
+ int, 0);
+ } else {
+ BT_ERR("out_param length is 0!!");
+ }
+ }
+
+ BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+
+ return result;
+}
+
+BT_EXPORT_API int bluetooth_register_proximity_reporter()
+{
+ int result = BLUETOOTH_ERROR_INTERNAL;
+
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ BT_DBG("");
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PXP_REGISTER_REPORTER,
+ 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_unregister_proximity_reporter()
+{
+ int result = BLUETOOTH_ERROR_INTERNAL;
+
+ BT_CHECK_ENABLED(return);
+
+ BT_INIT_PARAMS();
+ BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
+ BT_DBG("");
+
+ result = _bt_send_request(BT_BLUEZ_SERVICE, BT_PXP_UNREGISTER_REPORTER,
+ 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;
+}
ret_if(output == NULL);
*param_data = &g_array_index(output, char, 0);
break;
+ case BT_REQ_ATT_MTU:
+ *event_type = BT_DEVICE_EVENT;
+ *event = BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED;
+ ret_if(output == NULL);
+ *param_data = &g_array_index(output,
+ bluetooth_device_address_t, 0);
+ break;
case BT_CONNECT_LE:
*event_type = BT_DEVICE_EVENT;
*event = BLUETOOTH_EVENT_GATT_CONNECTED;
}
static void __send_request_cb(GDBusProxy *proxy,
- GAsyncResult *res,
- gpointer user_data)
+ GAsyncResult *res,
+ gpointer user_data)
{
bluetooth_event_param_t bt_event;
bt_req_info_t *cb_data = user_data;
goto done;
}
-
}
if (cb_data->cb == NULL)
in_param4->data, in_param4->len,
TRUE, NULL, NULL);
param5 = g_variant_new_from_data((const GVariantType *)"ay",
- in_param5->data, in_param5->len,
+ in_param5->data, in_param5->len,
TRUE, NULL, NULL);
ret = g_dbus_proxy_call_sync(proxy, "service_request",
typedef struct {
char bt_addr[BT_ADDRESS_STRING_SIZE];
int fd;
- int watch_id;
+ guint watch_id;
gboolean disconnected;
} rfcomm_conn_info_t;
if (conn == NULL)
return;
- if (conn->fd > 0)
- close(conn->fd);
if (conn->watch_id > 0) {
g_source_remove(conn->watch_id);
conn->watch_id = 0;
}
+
g_free(conn);
BT_DBG("-");
static void __rfcomm_client_connected_cb(rfcomm_cb_data_t *info,
char *dev_address, int result)
{
+ if (g_slist_find(rfcomm_clients, info) == NULL) {
+ BT_INFO("rfcomm resource is already freed");
+ return;
+ }
+
__client_connected_cb(info, dev_address, result);
__rfcomm_remove_conn_info_t(info, dev_address);
bluetooth_rfcomm_disconnection_t disconn_info;
bt_event_info_t *event_info = NULL;
+
if (conn_info->disconnected == FALSE)
return;
+
event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
if (event_info == NULL) {
+ __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
+
if (info->rfcomm_conns == NULL)
rfcomm_cb_data_remove(info);
return;
}
+
memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
disconn_info.device_role = RFCOMM_ROLE_CLIENT;
g_strlcpy(disconn_info.uuid, info->uuid, BLUETOOTH_UUID_STRING_MAX);
- BT_DBG("Disconnected FD [%d]", conn_info->fd);
_bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
conn_info->bt_addr);
+ BT_DBG("Disconnected FD [%d]", conn_info->fd);
disconn_info.socket_fd = conn_info->fd;
BT_DBG("Disconnection Result[%d] BT_ADDRESS[%s] UUID[%s] FD[%d]",
BLUETOOTH_ERROR_NONE, &disconn_info,
event_info->cb, event_info->user_data);
- if (conn_info) {
- BT_DBG("List is present deleting it");
- __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
- }
+ __rfcomm_remove_conn_info_t(info, conn_info->bt_addr);
+
if (info->rfcomm_conns == NULL)
rfcomm_cb_data_remove(info);
static gboolean __rfcomm_client_disconnect(gpointer user_data)
{
- rfcomm_cb_data_t *info = (rfcomm_cb_data_t *) user_data;
- BT_INFO_C("Disconnected [RFCOMM Client]");
+ rfcomm_cb_data_t *info = (rfcomm_cb_data_t *)user_data;
+
+ BT_INFO_C("### Disconnected [RFCOMM Client]");
+
retv_if(info == NULL, FALSE);
if (g_slist_find(rfcomm_clients, info) == NULL) {
return FALSE;
}
info->idle_id = 0;
+
g_slist_foreach(info->rfcomm_conns,
- (GFunc) _bt_rfcomm_disconnect_conn_info, info);
+ (GFunc)_bt_rfcomm_disconnect_conn_info, info);
+
BT_DBG("-");
return FALSE;
}
fd = g_io_channel_unix_get_fd(chan);
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
BT_ERR_C("RFComm Client disconnected: %d", fd);
+
conn_info = __get_conn_info_from_fd(info, fd);
if (conn_info == NULL) {
BT_ERR("No Connection info found with FD [%d]", fd);
return FALSE;
}
- conn_info->disconnected = TRUE;
+
+ if (conn_info->disconnected == FALSE) {
+ close(conn_info->fd);
+ conn_info->disconnected = TRUE;
+ }
__rfcomm_client_disconnect(info);
return FALSE;
}
__is_error_by_disconnect(err)) {
BT_ERR("cond : %d", cond);
g_error_free(err);
+
conn_info = __get_conn_info_from_fd(info, fd);
if (conn_info == NULL) {
BT_ERR("No Connection info found with FD [%d]", fd);
return FALSE;
}
- conn_info->disconnected = TRUE;
+
+ if (conn_info->disconnected == FALSE) {
+ close(conn_info->fd);
+ conn_info->disconnected = TRUE;
+ }
__rfcomm_client_disconnect(info);
return FALSE;
}
bluetooth_rfcomm_connection_t conn_info;
bt_event_info_t *event_info;
rfcomm_conn_info_t *conn_list_info = NULL;
- BT_INFO_C("Connected [RFCOMM Client]");
+
+ if (result == BLUETOOTH_ERROR_NONE)
+ BT_INFO_C("### Connected [RFCOMM Client]");
event_info = _bt_event_get_cb_data(BT_RFCOMM_CLIENT_EVENT);
if (event_info == NULL)
{
GError *error = NULL;
+ GVariant *value;
rfcomm_cb_data_t *cb_data;
char dev_address[BT_ADDRESS_STRING_SIZE];
const char *path;
cb_data = user_data;
- if (!g_dbus_proxy_call_finish(proxy, res, &error)) {
+ value = g_dbus_proxy_call_finish(proxy, res, &error);
+ if (value == NULL) {
int result;
g_dbus_error_strip_remote_error(error);
BT_ERR("Error : %s \n", error->message);
__rfcomm_client_connected_cb(cb_data, dev_address, result);
g_error_free(error);
+ } else {
+ g_variant_unref(value);
}
+
if (proxy)
g_object_unref(proxy);
rfcomm_cb_data_t *cb_data;
int ret = 0;
GError *err = NULL;
+ GVariant *value;
bt_register_profile_info_t info = {0};
int result = BLUETOOTH_ERROR_NONE;
char dev_address[BT_ADDRESS_STRING_SIZE];
_bt_convert_device_path_to_address(path, dev_address);
BT_DBG("Device Adress [%s]", dev_address);
- g_dbus_proxy_call_finish(proxy, res, &err);
+ value = g_dbus_proxy_call_finish(proxy, res, &err);
if (proxy)
g_object_unref(proxy);
+ if (value)
+ g_variant_unref(value);
if (err != NULL) {
g_dbus_error_strip_remote_error(err);
#endif
#ifdef RFCOMM_DIRECT
- BT_INFO_C("<<<<<<<<< RFCOMM Connect request from app >>>>>>>>>>>");
+ BT_INFO_C("### Connect RFCOMM");
int ret;
int id, object_id;
char *path;
cb_data->object_id = object_id;
cb_data->id = id;
}
+
conn = g_new0(rfcomm_conn_info_t, 1);
conn->fd = -1;
_bt_convert_addr_type_to_string(conn->bt_addr,
BT_DBG("Connecting to %s uuid %s", conn->bt_addr, remote_uuid);
cb_data->rfcomm_conns = g_slist_append(cb_data->rfcomm_conns, conn);
+
ret = _bt_discover_services(conn->bt_addr, (char *)remote_uuid,
__bt_discover_service_response_cb, cb_data);
if (ret != BLUETOOTH_ERROR_NONE) {
rfcomm_cb_data_remove(cb_data);
return BLUETOOTH_ERROR_INTERNAL;
}
+
if (g_slist_find(rfcomm_clients, cb_data) == NULL) {
BT_INFO("Adding callback information to rfcomm_clients");
rfcomm_clients = g_slist_append(rfcomm_clients, cb_data);
#ifdef RFCOMM_DIRECT
rfcomm_cb_data_t *info;
rfcomm_conn_info_t *conn_info;
- BT_INFO_C("<<<<<<<<< RFCOMM Disconnect request from app >>>>>>>>");
+
+ BT_INFO_C("### Disconnect RFCOMM");
+
BT_CHECK_ENABLED(return);
if (_bt_check_privilege(BT_BLUEZ_SERVICE, BT_RFCOMM_SOCKET_DISCONNECT)
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
+ BT_DBG("Requested FD %d", socket_fd);
if (socket_fd < 0) {
BT_ERR("Invalid FD");
return BLUETOOTH_ERROR_INVALID_PARAM;
BT_DBG("Could not find in client, so check in server");
return bluetooth_rfcomm_server_disconnect(socket_fd);
}
+
conn_info = __get_conn_info_from_fd(info, socket_fd);
if (conn_info == NULL) {
- BT_ERR("FATAL Error");
+ BT_ERR("Could not find connection info");
return BLUETOOTH_ERROR_INTERNAL;
}
- if (conn_info->watch_id <= 0) {
+
+ if (conn_info->watch_id == 0 || conn_info->disconnected) {
BT_ERR("Invalid state");
return BLUETOOTH_ERROR_NOT_CONNECTED;
}
+
+ close(conn_info->fd);
conn_info->disconnected = TRUE;
- close(socket_fd);
+
BT_INFO("conn_info %s", conn_info->bt_addr);
_bt_disconnect_profile(conn_info->bt_addr, info->uuid, NULL, NULL);
+
+ /*
+ * ToDo : If idle_id is not zero, it means disconnect request is
+ * going on. Such a case, in-progress error should be returned.
+ */
if (info->idle_id == 0)
info->idle_id = g_idle_add(__rfcomm_client_disconnect, info);
#endif
}
+#ifdef RFCOMM_DIRECT
+#else
static int __write_all(int fd, const char *buf, int len)
{
int sent = 0;
BT_DBG("-");
return sent;
}
+#endif
BT_EXPORT_API int bluetooth_rfcomm_write(int fd, const char *buf, int length)
{
static GSList *rfcomm_nodes;
typedef struct {
+ bluetooth_device_address_t addr;
+ int fd;
+ guint watch_id;
+ gboolean disconnected;
+} rfcomm_conn_t;
+
+typedef struct {
guint object_id;
gchar *path;
int id;
char *uuid;
- int fd;
- GIOChannel *data_io;
- guint data_id;
- bluetooth_device_address_t addr;
+ GSList *rfcomm_conns;
guint disconnect_idle_id;
} rfcomm_info_t;
static rfcomm_info_t *__find_rfcomm_info_with_fd(int fd)
{
GSList *l;
+ GSList *ll;
for (l = rfcomm_nodes; l != NULL; l = l->next) {
rfcomm_info_t *info = l->data;
- if (info->fd == fd)
- return info;
+ for (ll = info->rfcomm_conns; ll; ll = ll->next) {
+ rfcomm_conn_t *conn = ll->data;
+
+ if (conn && conn->fd == fd)
+ return info;
+ }
}
return NULL;
return NULL;
}
+static rfcomm_conn_t *__find_rfcomm_conn_with_fd(rfcomm_info_t *info,
+ int fd)
+{
+ GSList *l;
+ rfcomm_conn_t *conn;
+
+ for (l = info->rfcomm_conns; l; l = l->next) {
+ conn = l->data;
+
+ if (conn && conn->fd == fd)
+ return conn;
+ }
+
+ return NULL;
+}
+
+static void __rfcomm_remove_conn(rfcomm_info_t *info, int fd)
+{
+ rfcomm_conn_t *conn;
+
+ conn = __find_rfcomm_conn_with_fd(info, fd);
+ if (conn == NULL)
+ return;
+
+ info->rfcomm_conns = g_slist_remove(info->rfcomm_conns, conn);
+
+ if (conn->watch_id > 0)
+ g_source_remove(conn->watch_id);
+ g_free(conn);
+}
+
gboolean _check_uuid_path(char *path, char *uuid)
{
rfcomm_info_t *info = NULL;
return FALSE;
}
-static void __connected_cb(rfcomm_info_t *info, bt_event_info_t *event_info)
+static void __connected_cb(rfcomm_info_t *info, rfcomm_conn_t *conn,
+ bt_event_info_t *event_info)
{
bluetooth_rfcomm_connection_t conn_info;
memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
+
conn_info.device_role = RFCOMM_ROLE_SERVER;
g_strlcpy(conn_info.uuid, info->uuid, BLUETOOTH_UUID_STRING_MAX);
- conn_info.socket_fd = info->fd;
- conn_info.device_addr = info->addr;
+ conn_info.socket_fd = conn->fd;
+ conn_info.device_addr = conn->addr;
conn_info.server_id = info->id;
- BT_INFO_C("Connected [RFCOMM Server]");
+ BT_INFO_C("### Connected [RFCOMM Server]");
_bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
BLUETOOTH_ERROR_NONE, &conn_info,
event_info->cb, event_info->user_data);
}
-static gboolean __rfcomm_server_disconnect(rfcomm_info_t *info)
+static void __rfcomm_server_disconnect_conn(rfcomm_conn_t *conn,
+ rfcomm_info_t *info)
{
bluetooth_rfcomm_disconnection_t disconn_info;
- int fd = info->fd;
bt_event_info_t *event_info;
- BT_INFO_C("Disconnected [RFCOMM Server]");
+ if (conn == NULL)
+ return;
- if (info->data_id > 0) {
- g_source_remove(info->data_id);
- info->data_id = 0;
- }
+ if (conn->disconnected == FALSE)
+ return;
- if (info->fd >= 0) {
- close(info->fd);
- info->fd = -1;
+ if (conn->watch_id > 0) {
+ g_source_remove(conn->watch_id);
+ conn->watch_id = 0;
}
- if (info->data_io) {
- g_io_channel_shutdown(info->data_io, TRUE, NULL);
- g_io_channel_unref(info->data_io);
- info->data_io = NULL;
- }
- info->disconnect_idle_id = 0;
event_info = _bt_event_get_cb_data(BT_RFCOMM_SERVER_EVENT);
- if (event_info == NULL)
- return FALSE;
+ if (event_info == NULL) {
+ __rfcomm_remove_conn(info, conn->fd);
+ return;
+ }
memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
disconn_info.device_role = RFCOMM_ROLE_SERVER;
g_strlcpy(disconn_info.uuid, info->uuid, BLUETOOTH_UUID_STRING_MAX);
- disconn_info.socket_fd = fd;
- disconn_info.device_addr = info->addr;
+ disconn_info.device_addr = conn->addr;
+
+ BT_DBG("Disconnected FD [%d]", conn->fd);
+ disconn_info.socket_fd = conn->fd;
_bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
BLUETOOTH_ERROR_NONE, &disconn_info,
event_info->cb, event_info->user_data);
+ __rfcomm_remove_conn(info, conn->fd);
+}
+
+static gboolean __rfcomm_server_disconnect(rfcomm_info_t *info)
+{
+ BT_INFO_C("### Disconnected [RFCOMM Server]");
+
+ if (g_slist_find(rfcomm_nodes, info) == NULL) {
+ BT_INFO("rfcomm resource is already freed");
+ return FALSE;
+ }
+
+ info->disconnect_idle_id = 0;
+
+ g_slist_foreach(info->rfcomm_conns,
+ (GFunc)__rfcomm_server_disconnect_conn, info);
+
BT_DBG("-");
return FALSE;
}
+static gboolean __is_error_by_disconnect(GError *err)
+{
+ return !g_strcmp0(err->message, "Connection reset by peer") ||
+ !g_strcmp0(err->message, "Connection timed out") ||
+ !g_strcmp0(err->message, "Software caused connection abort");
+}
+
static gboolean __data_received_cb(GIOChannel *chan, GIOCondition cond,
gpointer data)
{
gsize len = 0;
int result = BLUETOOTH_ERROR_NONE;
rfcomm_info_t *info = data;
+ rfcomm_conn_t *conn;
bt_event_info_t *event_info;
bluetooth_rfcomm_received_data_t data_r;
GIOStatus status = G_IO_STATUS_NORMAL;
GError *err = NULL;
+ int fd;
retv_if(info == NULL, FALSE);
- event_info = _bt_event_get_cb_data(BT_RFCOMM_SERVER_EVENT);
-
+ fd = g_io_channel_unix_get_fd(chan);
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
- BT_ERR_C("RFComm Server disconnected: %d", info->fd);
+ BT_ERR_C("RFComm Server disconnected: %d", fd);
if (info->disconnect_idle_id > 0) {
BT_INFO("Disconnect idle still not process remove source");
info->disconnect_idle_id = 0;
}
+ conn = __find_rfcomm_conn_with_fd(info, fd);
+ if (conn == NULL) {
+ BT_ERR("No Connection info found with FD [%d]", fd);
+ return FALSE;
+ }
+
+ if (conn->disconnected == FALSE) {
+ close(conn->fd);
+ conn->disconnected = TRUE;
+ }
__rfcomm_server_disconnect(info);
return FALSE;
}
buffer = g_malloc0(BT_RFCOMM_BUFFER_LEN + 1);
status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
- &len, &err);
+ &len, &err);
if (status != G_IO_STATUS_NORMAL) {
BT_ERR("IO Channel read is failed with %d", status);
g_free(buffer);
- if (err) {
- BT_ERR("IO Channel read error [%s]", err->message);
- if (status == G_IO_STATUS_ERROR &&
- !g_strcmp0(err->message, "Connection reset by peer")) {
- BT_ERR("cond : %d", cond);
- g_error_free(err);
- if (info->disconnect_idle_id > 0) {
- BT_INFO("Disconnect idle still not process remove source");
- g_source_remove(info->disconnect_idle_id);
- info->disconnect_idle_id = 0;
- }
- __rfcomm_server_disconnect(info);
+ if (!err)
+ return TRUE;
+
+ BT_ERR("IO Channel read error [%s]", err->message);
+ if (status == G_IO_STATUS_ERROR &&
+ __is_error_by_disconnect(err)) {
+ BT_ERR("cond : %d", cond);
+ g_error_free(err);
+
+ if (info->disconnect_idle_id > 0) {
+ BT_INFO("Disconnect idle still not process remove source");
+ g_source_remove(info->disconnect_idle_id);
+ info->disconnect_idle_id = 0;
+ }
+
+ conn = __find_rfcomm_conn_with_fd(info, fd);
+ if (conn == NULL) {
+ BT_ERR("No Connection info found with FD [%d]", fd);
return FALSE;
}
- g_error_free(err);
+
+ if (conn->disconnected == FALSE) {
+ close(conn->fd);
+ conn->disconnected = TRUE;
+ }
+ __rfcomm_server_disconnect(info);
+ return FALSE;
}
+ g_error_free(err);
return TRUE;
}
if (len == 0)
BT_ERR("Length is zero");
+ event_info = _bt_event_get_cb_data(BT_RFCOMM_SERVER_EVENT);
if (event_info == NULL) {
g_free(buffer);
return TRUE;
}
- data_r.socket_fd = info->fd;
+ data_r.socket_fd = fd;
data_r.buffer_size = len;
data_r.buffer = buffer;
int new_server_connection(const char *path, int fd, bluetooth_device_address_t *addr)
{
rfcomm_info_t *info;
+ rfcomm_conn_t *conn;
+ GIOChannel *data_io;
bt_event_info_t *event_info;
BT_DBG("%s %d", path, fd);
if (info == NULL)
return -1;
- info->fd = fd;
- memcpy(&info->addr, addr, sizeof(bluetooth_device_address_t));
+ conn = g_new0(rfcomm_conn_t, 1);
+ conn->fd = fd;
+ memcpy(&conn->addr, addr, sizeof(bluetooth_device_address_t));
+ info->rfcomm_conns = g_slist_append(info->rfcomm_conns, conn);
- info->data_io = g_io_channel_unix_new(info->fd);
+ data_io = g_io_channel_unix_new(conn->fd);
- g_io_channel_set_encoding(info->data_io, NULL, NULL);
- g_io_channel_set_flags(info->data_io, G_IO_FLAG_NONBLOCK, NULL);
+ g_io_channel_set_encoding(data_io, NULL, NULL);
+ g_io_channel_set_flags(data_io, G_IO_FLAG_NONBLOCK, NULL);
- info->data_id = g_io_add_watch(info->data_io,
+ conn->watch_id = g_io_add_watch(data_io,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
__data_received_cb, info);
+ g_io_channel_unref(data_io);
+
event_info = _bt_event_get_cb_data(BT_RFCOMM_SERVER_EVENT);
- if (event_info) {
- __connected_cb(info, event_info);
- }
+ if (event_info)
+ __connected_cb(info, conn, event_info);
return 0;
}
__rfcomm_delete_id(id);
return NULL;
}
- info = g_new(rfcomm_info_t, 1);
+ info = g_new0(rfcomm_info_t, 1);
info->object_id = (guint)object_id;
info->path = path;
info->id = id;
- info->fd = -1;
rfcomm_nodes = g_slist_append(rfcomm_nodes, info);
int object_id;
object_id = _bt_register_new_conn_ex(path, bus_name, new_server_connection);
- if (object_id < 0) {
+ if (object_id < 0)
return NULL;
- }
- info = g_new(rfcomm_info_t, 1);
+
+ info = g_new0(rfcomm_info_t, 1);
info->object_id = (guint)object_id;
info->path = g_strdup(path);
info->id = -1;
- info->fd = -1;
rfcomm_nodes = g_slist_append(rfcomm_nodes, info);
return info;
}
-void free_rfcomm_info(rfcomm_info_t *info)
+void free_rfcomm_conn(rfcomm_conn_t *conn, rfcomm_info_t *info)
{
- bt_event_info_t *event_info;
+ if (conn->disconnected == FALSE) {
+ close(conn->fd);
+ conn->disconnected = TRUE;
+ }
+ __rfcomm_server_disconnect_conn(conn, info);
+}
+void free_rfcomm_info(rfcomm_info_t *info)
+{
BT_DBG("");
+
if (info->disconnect_idle_id > 0) {
BT_INFO("Disconnect idle still not process remove source");
g_source_remove(info->disconnect_idle_id);
__rfcomm_delete_id(info->id);
_bt_unregister_gdbus(info->object_id);
- if (info->fd >= 0) {
- event_info = _bt_event_get_cb_data(BT_RFCOMM_SERVER_EVENT);
- if (event_info)
- BT_DBG("event type %d", event_info->event_type);
- __rfcomm_server_disconnect(info);
- }
+ g_slist_foreach(info->rfcomm_conns, (GFunc)free_rfcomm_conn, info);
g_free(info->path);
g_free(info->uuid);
BT_INFO("UUID Provided %s", uuid);
if (_bt_check_privilege(BT_BLUEZ_SERVICE, BT_RFCOMM_CREATE_SOCKET)
- == BLUETOOTH_ERROR_PERMISSION_DEINED) {
+ == BLUETOOTH_ERROR_PERMISSION_DEINED) {
BT_ERR("Don't have a privilege to use this API");
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
- BT_INFO("<<<<<<<<< RFCOMM Remove socket request from app, uuid=[%s] >>>>>>>>>>>", uuid);
+ BT_INFO("RFCOMM Remove socket request from app, uuid=[%s]", uuid);
info = __find_rfcomm_info_with_uuid(uuid);
if (info == NULL)
{
#ifdef RFCOMM_DIRECT
rfcomm_info_t *info;
+ rfcomm_conn_t *conn;
char address[20];
- BT_INFO(">>>>>>>>RFCOMM server disconnect request from APP>>>>>>>>>");
+ BT_INFO("### Disconnect RFCOMM server");
if (socket_fd < 0) {
BT_ERR("Invalid FD");
return BLUETOOTH_ERROR_INVALID_PARAM;
if (info == NULL)
return BLUETOOTH_ERROR_INVALID_PARAM;
- if (info->data_io == NULL)
+ conn = __find_rfcomm_conn_with_fd(info, socket_fd);
+ if (conn == NULL)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (conn->watch_id == 0 || conn->disconnected)
return BLUETOOTH_ERROR_NOT_CONNECTED;
- g_io_channel_shutdown(info->data_io, TRUE, NULL);
- g_io_channel_unref(info->data_io);
- info->data_io = NULL;
+ close(conn->fd);
+ conn->disconnected = TRUE;
+
+ _bt_convert_addr_type_to_string(address, conn->addr.addr);
- _bt_convert_addr_type_to_string(address, info->addr.addr);
BT_DBG("Address %s", address);
_bt_disconnect_profile(address, info->uuid, NULL, NULL);
- info->disconnect_idle_id = g_idle_add((GSourceFunc)
- __rfcomm_server_disconnect, info);
+ if (info->disconnect_idle_id == 0)
+ info->disconnect_idle_id = g_idle_add(
+ (GSourceFunc)__rfcomm_server_disconnect, info);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
BT_DBG("result: %x", result);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
available = g_array_index(out_param, gboolean, 0);
- }
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_EXPORT_API int bluetooth_rfcomm_server_is_connected(const bluetooth_device_address_t *device_address, gboolean *connected)
{
- char input_addr[BT_ADDRESS_STRING_SIZE] = { 0 };
#ifdef RFCOMM_DIRECT
GSList *l;
+ GSList *ll;
rfcomm_info_t *info;
- char connected_addr[BT_ADDRESS_STRING_SIZE] = { 0 };
+ rfcomm_conn_t *conn;
#else
+ char input_addr[BT_ADDRESS_STRING_SIZE] = { 0 };
rfcomm_remote_client_info_t *info;
#endif
BT_CHECK_PARAMETER(connected, return);
*connected = FALSE;
- _bt_convert_addr_type_to_string(input_addr, (unsigned char *)device_address->addr);
#ifdef RFCOMM_DIRECT
- for (l = rfcomm_nodes; l != NULL; l = l->next) {
+ for (l = rfcomm_nodes; l; l = l->next) {
info = l->data;
- if (info == NULL)
+ if (info == NULL || info->rfcomm_conns == NULL)
continue;
- _bt_convert_addr_type_to_string(connected_addr, info->addr.addr);
- if (g_strcmp0(connected_addr, input_addr) == 0) {
+ for (ll = info->rfcomm_conns; ll; ll = ll->next) {
+ conn = ll->data;
+
+ if (memcmp(device_address, &conn->addr,
+ sizeof(bluetooth_device_address_t)))
+ continue;
+
*connected = TRUE;
return BLUETOOTH_ERROR_NONE;
}
return BLUETOOTH_ERROR_NONE;
#else
+ _bt_convert_addr_type_to_string(input_addr, (unsigned char *)device_address->addr);
info = __get_rfcomm_rem_client_info_with_addr(input_addr);
if (info)
*connected = TRUE;
- return BLUETOOTH_ERROR_NOT_SUPPORT;
+ return BLUETOOTH_ERROR_NONE;
#endif
}
}
#ifdef RFCOMM_DIRECT
- BT_INFO("<<<<<<<<< RFCOMM Listen & accept from app >>>>>>>>>>>");
+ BT_INFO("RFCOMM Listen & accept from app");
info = __find_rfcomm_info_with_id(socket_fd);
if (info == NULL)
#endif
}
-BT_EXPORT_API int bluetooth_rfcomm_listen_and_accept_ex(const char *uuid, int max_pending_connection, const char *bus_name, const char *path)
+BT_EXPORT_API int bluetooth_rfcomm_listen_and_accept_ex(const char *uuid,
+ int max_pending_connection,
+ const char *bus_name, const char *path)
{
#ifdef RFCOMM_DIRECT
rfcomm_info_t *info;
}
#endif
- BT_INFO("<<<<<<<<< RFCOMM Listen & accept from app >>>>>>>>>>>");
+ BT_INFO("RFCOMM Listen & accept from app");
info = __find_rfcomm_info_with_uuid(uuid);
if (info == NULL)
}
#ifdef RFCOMM_DIRECT
- BT_INFO("<<<<<<<<< RFCOMM Listen >>>>>>>>>>>");
+ BT_INFO("RFCOMM Listen");
info = __find_rfcomm_info_with_id(socket_fd);
if (info == NULL)
const char *interface, const char *method,
GError **err, GVariant *parameters)
{
-#ifdef TIZEN_WEARABLE
+#if defined(TIZEN_PROFILE_WEARABLE) || defined(TIZEN_PROFILE_IVI)
int timeout = 4000;
#else
int timeout = -1;
return BLUETOOTH_TELEPHONY_ERROR_NONE;
}
-#ifndef TIZEN_WEARABLE
+#if defined(TIZEN_PROFILE_WEARABLE) || defined(TIZEN_PROFILE_IVI)
static void __bluetooth_telephony_init_headset_state(void)
{
GVariant *reply;
if (is_initialized == TRUE) {
BT_ERR("Bluetooth telephony already initilized");
- return BLUETOOTH_TELEPHONY_ERROR_ALREADY_INITIALIZED;
+ return BLUETOOTH_TELEPHONY_ERROR_NONE;
}
is_initialized = TRUE;
/* Call Path */
snprintf(telephony_info.call_path, sizeof(telephony_info.call_path),
CSD_CALL_APP_PATH, getpid());
- BT_DBG("Call Path = %s", telephony_info.call_path);
+ BT_INFO("Call Path = %s", telephony_info.call_path);
memset(telephony_info.address, 0x00, sizeof(telephony_info.address));
if (__bluetooth_telephony_proxy_init()) {
goto fail;
}
-#ifndef TIZEN_WEARABLE
+#if defined(TIZEN_PROFILE_WEARABLE) || defined(TIZEN_PROFILE_IVI)
__bluetooth_telephony_init_headset_state();
#endif
telephony_dbus_info.manager_proxy = NULL;
}
- if (telephony_dbus_info.conn != NULL) {
+ if (telephony_dbus_info.conn != NULL)
telephony_dbus_info.conn = NULL;
- }
if (telephony_dbus_info.dbus_proxy != NULL) {
g_object_unref(telephony_dbus_info.dbus_proxy);
g_variant_get(reply, "(b)", &status);
g_variant_unref(reply);
-#ifdef TIZEN_WEARABLE
+#if defined(TIZEN_PROFILE_WEARABLE) || defined(TIZEN_PROFILE_IVI)
if (status == TRUE && telephony_info.headset_state != BLUETOOTH_STATE_PLAYING)
telephony_info.headset_state = BLUETOOTH_STATE_PLAYING;
#endif
#define LOG_COLOR_PURPLE "\033[35m"
#define BT_DBG(fmt, args...) \
- SLOGD(fmt, ##args)
+ SLOGD(fmt, ##args)
#define BT_INFO(fmt, args...) \
- SLOGI(fmt, ##args)
+ SLOGI(fmt, ##args)
#define BT_ERR(fmt, args...) \
- SLOGE(fmt, ##args)
+ SLOGE(fmt, ##args)
#define BT_DBG_UUID(uuids, len, i) \
BT_DBG("***UUIDs***"); \
#define BT_ALLOC_PARAMS(IP1, IP2, IP3, IP4, OP) \
do { \
- IP1 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
- IP2 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
- IP3 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
- IP4 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP1 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP2 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP3 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP4 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
} while (0)
#define BT_INIT_AGENT_PARAMS() \
#define BT_ALLOC_AGENT_PARAMS(IP, OP) \
do { \
- IP = g_array_new(FALSE, FALSE, sizeof(gchar)); \
+ IP = g_array_new(FALSE, FALSE, sizeof(gchar)); \
} while (0)
#define BT_CHECK_PARAMETER(arg, func) \
} \
} while (0)
+#define BT_CHECK_ENABLED_INTERNAL(func) \
+ do { \
+ if (_bt_check_enabled_internal() == FALSE) { \
+ BT_ERR("BT BREDR is not enabled"); \
+ func BLUETOOTH_ERROR_DEVICE_NOT_ENABLED; \
+ } \
+ } while (0)
+
#define BT_ADDRESS_LENGTH_MAX 6
#define BT_ADDRESS_STRING_SIZE 18
#define BT_ADAPTER_OBJECT_PATH_MAX 50
#define RFKILL_NODE "/dev/rfkill"
typedef enum {
- RFKILL_TYPE_ALL = 0,
- RFKILL_TYPE_WLAN,
- RFKILL_TYPE_BLUETOOTH,
- RFKILL_TYPE_UWB,
- RFKILL_TYPE_WIMAX,
- RFKILL_TYPE_WWAN,
- RFKILL_TYPE_GPS,
- RFKILL_TYPE_FM,
- NUM_RFKILL_TYPES,
+ RFKILL_TYPE_ALL = 0,
+ RFKILL_TYPE_WLAN,
+ RFKILL_TYPE_BLUETOOTH,
+ RFKILL_TYPE_UWB,
+ RFKILL_TYPE_WIMAX,
+ RFKILL_TYPE_WWAN,
+ RFKILL_TYPE_GPS,
+ RFKILL_TYPE_FM,
+ NUM_RFKILL_TYPES,
} rfkill_type;
typedef struct {
- unsigned int idx;
- unsigned char type;
- unsigned char op;
- unsigned char soft;
- unsigned char hard;
+ unsigned int idx;
+ unsigned char type;
+ unsigned char op;
+ unsigned char soft;
+ unsigned char hard;
} rfkill_event;
typedef enum {
void _bt_convert_addr_string_to_type(unsigned char *addr,
const char *address);
+void _bt_convert_addr_string_to_secure_string(char *addr,
+ const char *address);
+
void _bt_convert_addr_type_to_string(char *address,
unsigned char *addr);
int _bt_register_new_conn_ex(const char *path, const char *bus_name, bt_new_connection_cb cb);
void _bt_swap_addr(unsigned char *dst, const unsigned char *src);
-void _bt_device_path_to_address(const char *device_path, char *device_address);
+GDBusConnection *_bt_init_system_gdbus_conn(void);
GDBusConnection *g_bus_get_private_conn(void);
GVariant *_bt_get_managed_objects(void);
+gboolean _bt_check_enabled_internal(void);
+
+void _bt_set_adapter_internal_status(gboolean enabled);
+
+int _bt_get_uuid_specification_name(const char *uuid, char **name);
+
void _bt_convert_device_path_to_address(const char *device_path,
char *device_address);
void _bt_rfcomm_server_set_pending_conn(int server_id, char *address);
#endif
+void _bluetooth_hid_free_hid_info(void);
+
void _bt_hdp_app_remove_obj_info(unsigned int channe_id);
int _bt_hdp_app_acquire_fd(bt_hdp_connected_t *conn_info);
void _bt_unregister_name_owner_changed(void);
+int _bt_register_manager_subscribe_signal(gboolean subscribe);
+
+int _bt_hid_device_get_fd(const char *address, int *ctrl, int *intr);
+
+int new_hid_connection(const char *path, int fd, bluetooth_device_address_t *addr);
+
#ifdef __cplusplus
}
#endif
--- /dev/null
+/*
+ * 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>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_GATT_CLIENT_H_
+#define _BT_GATT_CLIENT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define GATT_SERV_INTERFACE "org.bluez.GattService1"
+#define GATT_CHAR_INTERFACE "org.bluez.GattCharacteristic1"
+#define GATT_DESC_INTERFACE "org.bluez.GattDescriptor1"
+
+#define GATT_USER_DESC_UUID "00002901-0000-1000-8000-00805f9b34fb"
+#define GATT_CHAR_CLIENT_CONF "00002902-0000-1000-8000-00805f9b34fb"
+#define GATT_CHAR_SERVER_CONF "00002903-0000-1000-8000-00805f9b34fb"
+#define GATT_CHAR_FORMAT "00002904-0000-1000-8000-00805f9b34fb"
+
+gboolean _bluetooth_gatt_check_service_change_watcher_address(
+ const bluetooth_device_address_t *device_addr);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_GATT_CLIENT_H_*/
#define _bt_send_request(a, b, format ...) ( \
{ \
- BT_INFO_C("Sync Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
+ if ((a != BT_CHECK_PRIVILEGE && (a == BT_BLUEZ_SERVICE || a == BT_OBEX_SERVICE)) && \
+ (b != BT_GET_LOCAL_NAME && b != BT_GET_LOCAL_ADDRESS && \
+ b != BT_GET_BONDED_DEVICE && b != BT_IS_DEVICE_CONNECTED && \
+ b != BT_GET_BONDED_DEVICES && b != BT_GET_DISCOVERABLE_MODE)) \
+ BT_INFO_C("Sync Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
+ else \
+ BT_DBG("Sync Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
_bt_sync_send_request(a, b, format); \
} \
)
#define _bt_send_request_async(a, b, format ...) ( \
{ \
- BT_INFO_C("Async Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
+ if ((a != BT_CHECK_PRIVILEGE && (a == BT_BLUEZ_SERVICE || a == BT_OBEX_SERVICE)) && \
+ (b != BT_GET_LOCAL_NAME && b != BT_GET_LOCAL_ADDRESS && \
+ b != BT_GET_BONDED_DEVICE && b != BT_IS_DEVICE_CONNECTED && \
+ b != BT_GET_BONDED_DEVICES && b != BT_GET_DISCOVERABLE_MODE)) \
+ BT_INFO_C("Async Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
+ else \
+ BT_DBG("Async Request => type=%s, fn=%s(0x%x)", #a, #b, b); \
_bt_async_send_request(a, b, format); \
} \
)
#include <vconf.h>
#include <vconf-keys.h>
+#include <vconf-internal-radio-keys.h>
#include <bundle.h>
#include <eventsystem.h>
static bt_status_t adapter_status = BT_DEACTIVATED;
static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
static gboolean is_recovery_mode = FALSE;
+static guint core_enable_timer_id;
+
static int bt_status_before[BT_MODE_MAX] = { VCONFKEY_BT_STATUS_OFF, };
static int bt_le_status_before[BT_MODE_MAX] = { VCONFKEY_BT_LE_STATUS_OFF, };
+static int __bt_eventsystem_set_value(const char *event, const char *key, const char *value);
+
static void __bt_core_set_status(bt_status_t status)
{
adapter_status = status;
gboolean _bt_core_is_flight_mode_enabled(void)
{
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
int isFlightMode = 0;
int ret = -1;
ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &isFlightMode);
- if (ret != 0) {
+ if (ret != 0)
BT_ERR("vconf_get_bool failed");
- }
+
return isFlightMode;
#else
return FALSE;
{
int ret;
bt_status_t status;
+#if 0
bt_le_status_t le_status;
-
+#endif
BT_INFO("");
status = _bt_core_get_status();
if (status != BT_DEACTIVATED) {
BT_ERR("Invalid state %d", status);
+ g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
return -1;
}
+#if 0 /* only the concept of private */
le_status = _bt_core_get_le_status();
if (le_status == BT_LE_ACTIVATED) {
/* Turn on PSCAN, (ISCAN if needed) */
g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
return 0;
}
+#endif
__bt_core_set_status(BT_ACTIVATING);
#ifdef USB_BLUETOOTH
int _bt_disable_adapter(void)
{
bt_status_t status;
+#if 0
bt_le_status_t le_status;
+#endif
BT_INFO_C("Disable adapter");
+#if 0 /* only the concept of private */
le_status = _bt_core_get_le_status();
BT_DBG("le_status : %d", le_status);
-#if 0 /* only the concept of private */
if (le_status == BT_LE_ACTIVATED) {
/* Turn off PSCAN, (ISCAN if needed) */
/* Return with 0 for the Disabled response. */
/* Forcely terminate */
#ifdef USB_BLUETOOTH
char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
- if (__execute_command("/usr/bin/hciconfig", argv_down) < 0) {
-#else
- if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
-#endif
+ if (__execute_command("/usr/bin/hciconfig", argv_down) < 0)
BT_ERR("running script failed");
+#else
+
+#ifdef TIZEN_FEATURE_RADIO
+ int radio_status = VCONFKEY_RADIO_STATUS_OFF;
+
+ /* Check if radio status on or off */
+ if (vconf_get_int(VCONFKEY_RADIO_STATUS, &radio_status) < 0)
+ BT_ERR("Fail to get radio status");
+
+ BT_DBG("Radio status: %d", radio_status);
+
+ if (radio_status == VCONFKEY_RADIO_STATUS_ON) {
+ if (__execute_command("/usr/etc/bluetooth/bt-stack-down-with-radio.sh", NULL) < 0)
+ BT_ERR("running script failed");
+ } else {
+ if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0)
+ BT_ERR("running script failed");
}
+#else
+ if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0)
+ BT_ERR("running script failed");
+#endif
+#endif
_bt_core_terminate();
return 0;
} else if (status != BT_ACTIVATED) {
BT_ERR("Invalid state %d", status);
+ g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
}
__bt_core_set_status(BT_DEACTIVATING);
#ifdef USB_BLUETOOTH
char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
if (__execute_command("/usr/bin/hciconfig", argv_down) < 0) {
-#else
- if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
-#endif
BT_ERR("running script failed");
__bt_core_set_status(BT_ACTIVATED);
return -1;
}
+#else
+#ifdef TIZEN_FEATURE_RADIO
+ int radio_status = VCONFKEY_RADIO_STATUS_OFF;
+
+ /* Check if radio status on or off */
+ if (vconf_get_int(VCONFKEY_RADIO_STATUS, &radio_status) < 0)
+ BT_ERR("Fail to get radio status");
+
+ BT_DBG("Radio status: %d", radio_status);
+
+ if (radio_status == VCONFKEY_RADIO_STATUS_ON) {
+ if (__execute_command("/usr/etc/bluetooth/bt-stack-down-with-radio.sh", NULL) < 0) {
+ BT_ERR("running script failed");
+ __bt_core_set_status(BT_ACTIVATED);
+ return -1;
+ }
+ } else {
+ if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
+ BT_ERR("running script failed");
+ __bt_core_set_status(BT_ACTIVATED);
+ return -1;
+ }
+ }
+#else
+ if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
+ BT_ERR("running script failed");
+ __bt_core_set_status(BT_ACTIVATED);
+ return -1;
+ }
+#endif
+#endif
return 0;
}
}
#ifdef HPS_FEATURE
ret = _bt_core_start_httpproxy();
- if (ret < 0) {
+ if (ret < 0)
BT_ERR("_bt_core_start_httpproxy() failed");
- }
#endif
return 0;
gboolean _bt_core_recover_adapter(void)
{
int ret;
+#if 0
int ret_le;
-
+#endif
BT_INFO_C("Recover bt adapter");
_bt_set_flightmode_request(FALSE);
if (_bt_core_get_status() == BT_ACTIVATED) {
_bt_core_set_bt_status(BT_RECOVERY_MODE, 1);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
+#endif
}
if (_bt_core_get_le_status() == BT_LE_ACTIVATED) {
_bt_core_set_bt_le_status(BT_RECOVERY_MODE, 1);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
+#endif
}
ret = _bt_disable_adapter();
if (ret < 0)
BT_ERR("_bt_disable_adapter() failed");
+
+/* In platform, don't seperate BR/EDR and LE status */
+#if 0
ret_le = _bt_disable_adapter_le();
if (ret_le < 0)
BT_ERR("_bt_disable_adapter_le() failed");
-
+#endif
return TRUE;
}
gboolean __bt_core_reset_adapter(void)
{
/* Forcely terminate */
- if (__execute_command("/usr/etc/bluetooth/bt-reset-env.sh", NULL) < 0) {
+ if (__execute_command("/usr/etc/bluetooth/bt-reset-env.sh", NULL) < 0)
BT_ERR("running script failed");
- }
+
_bt_core_terminate();
return TRUE;
{
BT_DBG("+");
+ core_enable_timer_id = 0;
+
_bt_core_init_vconf_value();
return FALSE;
_bt_core_update_status();
- g_timeout_add(200, (GSourceFunc)__bt_core_enable_core_timeout_cb, NULL);
+ if (core_enable_timer_id > 0)
+ g_source_remove(core_enable_timer_id);
+
+ core_enable_timer_id = g_timeout_add(200, (GSourceFunc)__bt_core_enable_core_timeout_cb, NULL);
BT_DBG("-");
return TRUE;
}
+gboolean _bt_core_set_transfer_value(gboolean value)
+{
+ const char *event_val = NULL;
+ gboolean ret = TRUE;
+
+ BT_DBG("value: %d", value);
+
+ event_val = value ? EVT_VAL_BT_TRANSFERING : EVT_VAL_BT_NON_TRANSFERING;
+
+ if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_TRANSFERING_STATE,
+ event_val) != ES_R_OK) {
+ BT_ERR("Fail to set BT state value");
+ ret = FALSE;
+ }
+
+ if (ret == FALSE || value == FALSE) {
+ BT_DBG("Terminate bt-core process");
+ g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
+ }
+
+ BT_DBG("-");
+ return ret;
+}
+
gboolean _bt_core_factory_test_mode(const char *type, const char *arg)
{
}
BT_DBG("Run %s", cmd);
- if (__execute_command(cmd, arg_list) < 0) {
+ if (__execute_command(cmd, arg_list) < 0)
BT_ERR("running script failed");
- }
_bt_core_terminate();
return TRUE;
static gboolean __bt_core_recovery_cb(gpointer data)
{
int ret = 0;
+#ifdef TIZEN_FEATURE_BUSACT
gboolean is_request_failed = FALSE;
static gboolean is_first_failure = TRUE;
+#endif
BT_DBG("+");
+#ifdef TIZEN_FEATURE_BUSACT
if (_bt_core_get_bt_status(BT_RECOVERY_MODE) == 1) {
ret = _bt_core_service_request_adapter(BT_ENABLE_ADAPTER);
if (ret < 0)
}
} else
is_first_failure = TRUE;
+#endif
if (_bt_core_get_bt_status(BT_RECOVERY_MODE) == 1) {
_bt_core_set_bt_status(BT_RECOVERY_MODE, 0);
if (ret < 0)
BT_ERR("_bt_enable_adapter() failed");
}
+
+#if 0
if (_bt_core_get_bt_le_status(BT_RECOVERY_MODE) == 1) {
_bt_core_set_bt_le_status(BT_RECOVERY_MODE, 0);
ret = _bt_enable_adapter_le();
if (ret < 0)
BT_ERR("_bt_enable_adapter_le() failed");
}
-
+#endif
is_recovery_mode = FALSE;
BT_DBG("-");
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
_bt_core_set_bt_status(BT_FLIGHT_MODE, bt_status_before_mode);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
+#endif
_bt_disable_adapter();
}
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
_bt_core_set_bt_le_status(BT_FLIGHT_MODE, bt_le_status_before_mode);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
+#endif
_bt_disable_adapter_le();
}
return;
}
_bt_set_flightmode_request(FALSE);
+
+ if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
+ EVT_VAL_BT_ON) != ES_R_OK)
+ BT_ERR("Fail to set BT state value");
+
+ if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
+ EVT_VAL_BT_LE_ON) != ES_R_OK)
+ BT_ERR("Fail to set BT LE state value");
+
_bt_core_terminate();
}
gboolean flight_mode_status;
static int timer_id = -1;
- BT_DBG("");
+ BT_DBG("is_recovery_mode: %d", is_recovery_mode);
__bt_core_set_status(BT_DEACTIVATED);
__bt_core_set_le_status(BT_LE_DEACTIVATED);
" </method>"
" <method name='EnableCore'>"
" </method>"
+" <method name='SetTransferValue'>"
+" <arg type='b' name='value' direction='in'/>"
+" </method>"
" <method name='FactoryTestMode'>"
" <arg type='s' name='type' direction='in'/>"
" <arg type='s' name='arg' direction='in'/>"
ret = _bt_core_disable_adapter_le();
} else if (g_strcmp0(method_name, "EnableCore") == 0) {
ret = _bt_core_enable_core();
+ } else if (g_strcmp0(method_name, "SetTransferValue") == 0) {
+ gboolean value = FALSE;
+
+ g_variant_get(parameters, "(b)", &value);
+ BT_DBG("Transfer value: %d", value);
+
+ ret = _bt_core_set_transfer_value(value);
} else if (g_strcmp0(method_name, "FactoryTestMode") == 0) {
const char *type = NULL;
const char *arg = NULL;
g_variant_get(parameters, "(&o@a{sa{sv}})",
&obj_path, &optional_param);
- if (g_strcmp0(obj_path, "/org/bluez/hci0") == 0) {
+ if (g_strcmp0(obj_path, "/org/bluez/hci0") == 0)
_bt_core_adapter_added_cb();
- }
+
} else if (!g_strcmp0(signal_name, "InterfacesRemoved")) {
char *obj_path = NULL;
GVariant *optional_param;
g_variant_get(parameters, "(&o@as)", &obj_path,
&optional_param);
- if (g_strcmp0(obj_path, "/org/bluez/hci0") == 0) {
+ if (g_strcmp0(obj_path, "/org/bluez/hci0") == 0)
_bt_core_adapter_removed_cb();
- }
+
} else { /* NameOwnerChanged */
const char *name = NULL;
const char *old_owner = NULL;
le_status = _bt_core_get_le_status();
BT_DBG("State: %d, LE State: %d", status, le_status);
- if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
BT_DBG("no bluetooth device info, so BT was disabled at previous session");
- }
#ifdef ENABLE_TIZEN_2_4
- if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0)
BT_ERR("no bluetooth le info, so BT LE was disabled at previous session");
- }
#endif
if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &flight_mode_deactivation) != 0)
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
_bt_core_set_bt_status(BT_FLIGHT_MODE, bt_status_before_mode);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
+#endif
#ifndef USB_BLUETOOTH
_bt_disable_adapter();
#endif
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
_bt_core_set_bt_le_status(BT_FLIGHT_MODE, bt_le_status_before_mode);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
+#endif
#ifndef USB_BLUETOOTH
_bt_disable_adapter_le();
#endif
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
_bt_core_set_bt_status(BT_POWER_SAVING_MODE, bt_status_before_mode);
+#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
+#endif
#ifndef USB_BLUETOOTH
_bt_disable_adapter();
#endif
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
_bt_core_set_bt_le_status(BT_POWER_SAVING_MODE, bt_le_status_before_mode);
+#ifdef TIZEN_FEATURE_BUSACT
/* Disable the BT LE */
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
+#endif
#ifndef USB_BLUETOOTH
_bt_disable_adapter_le();
#endif
}
}
}
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
static void __bt_core_flight_mode_cb(keynode_t *node, void *data)
{
gboolean flight_mode = FALSE;
}
#endif
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#ifdef ENABLE_TIZEN_2_4
static void __bt_core_power_saving_mode_cb(keynode_t *node, void *data)
{
flight_mode = _bt_core_is_flight_mode_enabled();
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#ifndef ENABLE_TIZEN_2_4
if (vconf_get_int(VCONFKEY_SETAPPL_PSMODE, &power_saving_mode) != 0)
BT_ERR("Fail to get the power_saving_mode status value");
void _bt_core_handle_flight_mode_noti(void)
{
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
int ret;
BT_DBG("+");
void _bt_core_handle_power_saving_mode_noti(void)
{
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
int ret = 0;
BT_DBG("+");
void _bt_core_unregister_vconf_handler(void)
{
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
(vconf_callback_fn)__bt_core_flight_mode_cb);
#endif
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#ifdef ENABLE_TIZEN_2_4
vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
(vconf_callback_fn)__bt_core_power_saving_mode_cb);
gboolean _bt_core_disable_adapter_le(void);
gboolean __bt_core_reset_adapter(void);
gboolean _bt_core_enable_core(void);
+gboolean _bt_core_set_transfer_value(gboolean value);
gboolean _bt_core_factory_test_mode(const char *type, const char *arg);
void _bt_core_update_status(void);
#define LOG_COLOR_PURPLE "\033[35m"
#define BT_DBG(fmt, args...) \
- SLOGD(fmt, ##args)
+ SLOGD(fmt, ##args)
#define BT_INFO(fmt, args...) \
SLOGI(fmt, ##args)
#define BT_ERR(fmt, args...) \
- SLOGE(fmt, ##args)
+ SLOGE(fmt, ##args)
#define BT_INFO_C(fmt, arg...) \
SLOGI_IF(TRUE, LOG_COLOR_GREEN" "fmt" "LOG_COLOR_RESET, ##arg)
#define BT_ALLOC_PARAMS(IP1, IP2, IP3, IP4, OP) \
do { \
- IP1 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
- IP2 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
- IP3 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
- IP4 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP1 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP2 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP3 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
+ IP4 = g_array_new(TRUE, TRUE, sizeof(gchar)); \
} while (0)
#ifdef __cplusplus
#define LOG_TAG "BLUETOOTH_FRWK_CORE"
#define BT_DBG(fmt, args...) \
- SLOGD(fmt, ##args)
+ SLOGD(fmt, ##args)
#define BT_INFO(fmt, args...) \
SLOGI(fmt, ##args)
#define BT_ERR(fmt, args...) \
- SLOGE(fmt, ##args)
+ SLOGE(fmt, ##args)
#define BT_CORE_NAME "org.projectx.bt_core"
#define BT_CORE_PATH "/org/projectx/bt_core"
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) {
+ if (i != BLUETOOTH_ADDRESS_LENGTH)
BT_ERR("Invalid format string - [%s]", addr_str);
- }
- for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++) {
+ for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++)
addr_hex->addr[i] = (unsigned char)addr[i];
- }
}
static void _bt_hps_send_status_notification(unsigned short http_status,
// Write Data to Status Code Characteristic
#ifdef HPS_GATT_DB
data_status = (hdr_len > MAX_ENTITY_LENGTH) ? DS_HEADER_TRUNCATED : DS_HEADER_RECEIVED;
- if (data_status == DS_BODY_TRUNCATED && SOUP_STATUS_IS_SUCCESSFUL(http_status)) {
+ if (data_status == DS_BODY_TRUNCATED && SOUP_STATUS_IS_SUCCESSFUL(http_status))
_bt_hps_set_notify_read_status(http_hdr_obj_path, data_status, 0, http_status);
- }
+
_bt_hps_send_status_notification(http_status, data_status, &addr_hex);
#else
status[0] = http_status & 0x0F;
// Write Data to Status Code Characteristic
#ifdef HPS_GATT_DB
data_status = (body->length > MAX_ENTITY_LENGTH) ? DS_BODY_TRUNCATED : DS_BODY_RECEIVED;
- if (data_status == DS_BODY_TRUNCATED && SOUP_STATUS_IS_SUCCESSFUL(http_status)) {
+ if (data_status == DS_BODY_TRUNCATED && SOUP_STATUS_IS_SUCCESSFUL(http_status))
_bt_hps_set_notify_read_status(http_entity_obj_path, data_status, 0, http_status);
- }
+
_bt_hps_send_status_notification(http_status, data_status, &addr_hex);
#else
// Write Data to Status Code Characteristic
#ifdef HPS_GATT_DB
data_status = (hdr_len > MAX_HEADER_LENGTH) ? DS_HEADER_TRUNCATED : DS_HEADER_RECEIVED;
- if (data_status == DS_HEADER_TRUNCATED && SOUP_STATUS_IS_SUCCESSFUL(http_status)) {
+ if (data_status == DS_HEADER_TRUNCATED && SOUP_STATUS_IS_SUCCESSFUL(http_status))
_bt_hps_set_notify_read_status(http_hdr_obj_path, data_status, 0, http_status);
- }
+
_bt_hps_send_status_notification(http_status, data_status, &addr_hex);
#else
status[0] = http_status & 0x0F;
#endif
switch (opcode) {
- case HTTP_GET_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("GET", g_uri);
+ case HTTP_GET_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("GET", g_uri);
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, NULL);
#endif
- } else {
- BT_ERR("HTTP GET request in progress, message dropped");
+ } else {
+ BT_ERR("HTTP GET request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTP_POST_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("POST", g_uri);
+ if (hps_soup_msg == NULL || g_entity == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTP_POST_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("POST", g_uri);
- if (hps_soup_msg == NULL || g_entity == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
- soup_message_set_request(hps_soup_msg, "text/xml", SOUP_MEMORY_COPY,
- g_entity, strlen(g_entity));
+ soup_message_set_request(hps_soup_msg, "text/xml", SOUP_MEMORY_COPY,
+ g_entity, strlen(g_entity));
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
#endif
- } else {
- BT_ERR("HTTP POST request in progress, message dropped");
+ } else {
+ BT_ERR("HTTP POST request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTP_HEAD_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("HEAD", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTP_HEAD_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("HEAD", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, NULL);
#endif
- } else {
- BT_ERR("HTTP HEAD request in progress, message dropped");
+ } else {
+ BT_ERR("HTTP HEAD request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTP_PUT_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ SoupBuffer *buf;
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("PUT", g_uri);
+ if (hps_soup_msg == NULL || g_entity == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTP_PUT_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- SoupBuffer *buf;
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("PUT", g_uri);
- if (hps_soup_msg == NULL || g_entity == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
- buf = soup_buffer_new(SOUP_MEMORY_TAKE, g_entity, strlen(g_entity));
- soup_message_body_append_buffer(hps_soup_msg->request_body, buf);
- soup_message_body_set_accumulate(hps_soup_msg->request_body, FALSE);
+ buf = soup_buffer_new(SOUP_MEMORY_TAKE, g_entity, strlen(g_entity));
+ soup_message_body_append_buffer(hps_soup_msg->request_body, buf);
+ soup_message_body_set_accumulate(hps_soup_msg->request_body, FALSE);
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
#endif
- } else {
- BT_ERR("HTTP PUT request in progress, message dropped");
+ } else {
+ BT_ERR("HTTP PUT request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTP_DELETE_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("DELETE", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTP_DELETE_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("DELETE", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
#endif
- } else {
- BT_ERR("HTTP DELETE request in progress, message dropped");
+ } else {
+ BT_ERR("HTTP DELETE request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTPS_GET_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("GET", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTPS_GET_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("GET", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_get_response_cb, NULL);
#endif
- https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
+ https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
#ifdef HPS_GATT_DB
- _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
+ _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
#else
- bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
+ bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
#endif
- } else {
- BT_ERR("HTTPS GET request in progress, message dropped");
+ } else {
+ BT_ERR("HTTPS GET request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTPS_HEAD_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("HEAD", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTPS_HEAD_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("HEAD", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_head_response_cb, NULL);
#endif
- https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
+ https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
#ifdef HPS_GATT_DB
- _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
+ _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
#else
- bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
+ bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
#endif
- } else {
- BT_ERR("HTTPS HEAD request in progress, message dropped");
+ } else {
+ BT_ERR("HTTPS HEAD request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTPS_POST_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("POST", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTPS_POST_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("POST", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
- soup_message_set_request(hps_soup_msg, "text/xml", SOUP_MEMORY_STATIC,
- g_entity, strlen(g_entity));
+ soup_message_set_request(hps_soup_msg, "text/xml", SOUP_MEMORY_STATIC,
+ g_entity, strlen(g_entity));
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
#endif
- https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
+ https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
#ifdef HPS_GATT_DB
- _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
+ _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
#else
- bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
+ bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
#endif
- } else {
- BT_ERR("HTTPS POST request in progress, message dropped");
+ } else {
+ BT_ERR("HTTPS POST request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTPS_PUT_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ SoupBuffer *buf;
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("PUT", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTPS_PUT_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- SoupBuffer *buf;
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("PUT", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
- buf = soup_buffer_new(SOUP_MEMORY_TAKE, g_entity, strlen(g_entity));
- soup_message_body_append_buffer(hps_soup_msg->request_body, buf);
- soup_message_body_set_accumulate(hps_soup_msg->request_body, FALSE);
+ buf = soup_buffer_new(SOUP_MEMORY_TAKE, g_entity, strlen(g_entity));
+ soup_message_body_append_buffer(hps_soup_msg->request_body, buf);
+ soup_message_body_set_accumulate(hps_soup_msg->request_body, FALSE);
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
#endif
- https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
+ https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
#ifdef HPS_GATT_DB
- _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
+ _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
#else
- bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
+ bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
#endif
- } else {
- BT_ERR("HTTPS PUT request in progress, message dropped");
+ } else {
+ BT_ERR("HTTPS PUT request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTPS_DELETE_REQUEST:
+ if (req_state == HTTP_REQ_STATE_EXECUTED) {
+ req_state = HTTP_REQ_STATE_INPROGRESS;
+ hps_soup_msg = soup_message_new("DELETE", g_uri);
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTPS_DELETE_REQUEST:
- if (req_state == HTTP_REQ_STATE_EXECUTED) {
- req_state = HTTP_REQ_STATE_INPROGRESS;
- hps_soup_msg = soup_message_new("DELETE", g_uri);
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
#ifdef HPS_GATT_DB
- g_object_ref(hps_soup_msg);
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
+ g_object_ref(hps_soup_msg);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, addr);
#else
- soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
+ soup_session_queue_message(hps_soup_session, hps_soup_msg, _bt_hps_http_response_cb, NULL);
#endif
- https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
+ https_status = soup_message_get_https_status(hps_soup_msg, &cert, &flags);
#ifdef HPS_GATT_DB
- _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
+ _bt_hps_set_char_value(http_security_obj_path, (const char *)&https_status, 1);
#else
- bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
+ bluetooth_gatt_set_characteristic_value(http_security_obj_path, (char *)&https_status, 1);
#endif
- } else {
- BT_ERR("HTTPS DELETE request in progress, message dropped");
+ } else {
+ BT_ERR("HTTPS DELETE request in progress, message dropped");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ break;
+
+ case HTTP_REQUEST_CANCEL:
+ /* Cancel the outstanding request */
+ if (req_state == HTTP_REQ_STATE_INPROGRESS) {
+ req_state = HTTP_REQ_STATE_IDLE;
+ if (hps_soup_msg == NULL) {
+ BT_ERR("Soup Message NULL");
result = BLUETOOTH_ERROR_INTERNAL;
+ req_state = HTTP_REQ_STATE_EXECUTED;
+ break;
}
- break;
-
- case HTTP_REQUEST_CANCEL:
- /* Cancel the outstanding request */
- if (req_state == HTTP_REQ_STATE_INPROGRESS) {
- req_state = HTTP_REQ_STATE_IDLE;
- if (hps_soup_msg == NULL) {
- BT_ERR("Soup Message NULL");
- result = BLUETOOTH_ERROR_INTERNAL;
- req_state = HTTP_REQ_STATE_EXECUTED;
- break;
- }
- soup_session_cancel_message(hps_soup_session, hps_soup_msg, SOUP_STATUS_CANCELLED);
- hps_soup_msg = NULL;
- }
- break;
+ soup_session_cancel_message(hps_soup_session, hps_soup_msg, SOUP_STATUS_CANCELLED);
+ hps_soup_msg = NULL;
+ }
+ break;
- default:
- BT_ERR("Unknown opcode %0x", opcode);
- result = BLUETOOTH_ERROR_INTERNAL;
- break;
+ default:
+ BT_ERR("Unknown opcode %0x", opcode);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ break;
}
return result;
int ret;
BT_DBG("");
- // Temporary UUID is used. SIG have not yet defined the UUID yet
+ // Temporary UUID is used. SIG have not yet defined the UUID yet
guint8 data[4] = {0x03, 0x02, 0x00, 0x19};
bluetooth_advertising_data_t adv;
BT_DBG("");
switch (sig) {
- case SIGTERM:
- BT_DBG("caught signal - sigterm\n");
- break;
- case SIGINT:
- BT_DBG("caught signal - sigint\n");
- break;
- case SIGKILL:
- BT_DBG("caught signal - sigkill\n");
- break;
- default:
- BT_DBG("caught signal %d and ignored\n", sig);
- break;
+ case SIGTERM:
+ BT_DBG("caught signal - sigterm\n");
+ break;
+ case SIGINT:
+ BT_DBG("caught signal - sigint\n");
+ break;
+ case SIGKILL:
+ BT_DBG("caught signal - sigkill\n");
+ break;
+ default:
+ BT_DBG("caught signal %d and ignored\n", sig);
+ break;
}
}
_bt_hps_unregister_interface();
- if (main_loop != NULL) {
+ if (main_loop != NULL)
g_main_loop_quit(main_loop);
- }
}
void bt_hps_event_callback(int event, bluetooth_event_param_t* param,
BT_DBG("g_main_loop_quit called!");
- if (main_loop != NULL) {
+ if (main_loop != NULL)
g_main_loop_unref(main_loop);
- }
return 0;
}
dbus-glib-1
dbus-1
gio-2.0
+ gio-unix-2.0
alarm-service
capi-content-mime-type
capi-network-connection
storage
)
-IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_NETWORK_TETHERING_ENABLE")
+IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_FEATURE_NETWORK_TETHERING_ENABLE")
SET(PKG_MODULES ${PKG_MODULES}
- capi-network-tethering
+ capi-network-tethering
)
ENDIF()
ADD_DEFINITIONS("-DHPS_FEATURE")
ADD_DEFINITIONS("-DTIZEN_DPM_ENABLE")
-IF(LIBNOTIFY_SUPPORT OR LIBNOTIFICATION_SUPPORT)
- ADD_DEFINITIONS("-DDATA_DIR_ICON=\"${SHARE_INSTALL_PREFIX}\"")
- MESSAGE("Icon used for notification is : ${SHARE_INSTALL_PREFIX}/icons/default/bt-icon.png")
-ENDIF(LIBNOTIFY_SUPPORT OR LIBNOTIFICATION_SUPPORT)
-
SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie")
ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
static gboolean __bt_is_sync_function(int service_function)
{
/*TODO: Keep adding sync methods with expect replies from bluetooth service */
- if (service_function == BT_GET_LOCAL_ADDRESS
+ if (service_function == BT_ENABLE_ADAPTER
+ || service_function == BT_DISABLE_ADAPTER
+ || service_function == BT_GET_LOCAL_ADDRESS
|| service_function == BT_GET_LOCAL_NAME
|| service_function == BT_GET_LOCAL_VERSION
|| service_function == BT_GET_BONDED_DEVICES
case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
signal = BT_IPSP_DISCONNECTED;
break;
- case BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO:
- signal = BT_IPSP_BT_INTERFACE_INFO;
- break;
+// case BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO:
+// signal = BT_IPSP_BT_INTERFACE_INFO;
+// break;
case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
signal = BT_GATT_CHAR_VAL_CHANGED;
break;
if (app->owner && !strncasecmp(app->owner, name, strlen(name))) {
BT_DBG("Match found, name: %s", name);
_bt_hdp_app_unregister(app->app_id);
- break;
}
}
# install booting script
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf.in ${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf)
-IF (TIZEN_WEARABLE)
+IF (TIZEN_PROFILE_WEARABLE)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/wearable/stack_info DESTINATION /usr/etc/bluetooth/)
ELSE ()
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/mobile/stack_info DESTINATION /usr/etc/bluetooth/)
-ENDIF (TIZEN_WEARABLE)
+ENDIF (TIZEN_PROFILE_WEARABLE)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf DESTINATION /etc/dbus-1/system.d)
goto fail;
}
- if (result != BLUETOOTH_ERROR_NONE) {
+ if (result != BLUETOOTH_ERROR_NONE)
goto fail;
- }
if ((request_type == BT_ASYNC_REQ ||
service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) &&
} else {
/* Return result */
if (service_type == BT_CHECK_PRIVILEGE ||
- service_function != BT_OPP_PUSH_FILES) {
+ service_function != BT_OPP_PUSH_FILES) {
out_var = g_variant_new_from_data((const GVariantType *)"ay",
- out_param1->data, out_param1->len,
- TRUE, NULL, NULL);
+ out_param1->data, out_param1->len,
+ TRUE, NULL, NULL);
GVariant *temp = g_variant_new("(iv)", result, out_var);
g_dbus_method_invocation_return_value(invocation, temp);
int length = 0;
result = _bt_get_advertising_data(&adv, &length);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
g_array_append_vals(*out_param1, adv.data, length);
- }
+
break;
}
case BT_SET_ADVERTISING_DATA: {
int length = 0;
result = _bt_get_scan_response_data(&rsp, &length);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
g_array_append_vals(*out_param1, rsp.data, length);
- }
break;
}
&address, file_path,
file_count);
} else {
- BT_DBG("normal case");
- result = _bt_opp_client_push_files(request_id, context,
+ BT_DBG("normal case");
+ result = _bt_opp_client_push_files(request_id, context,
&address, file_path,
file_count);
}
- for (i = 0; i < file_count; i++) {
+ for (i = 0; i < file_count; i++)
g_free(file_path[i]);
- }
+
g_free(file_path);
g_array_free(param2, TRUE);
if (process_proxy)
int service_type,
const char *unique_name)
{
- int ret_val;
- gboolean result = TRUE;
- char *client_creds = NULL;
- char *user_creds = NULL;
- 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, };
-
- retv_if(unique_name == NULL, FALSE);
-
- BT_DBG("unique_name: %s", unique_name);
-
- retv_if(bt_service_conn == NULL, FALSE);
-
- ret_val = cynara_creds_get_default_client_method(&client_creds_method);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get default client method: %s", err_msg);
- return FALSE;
- }
-
- ret_val = cynara_creds_get_default_user_method(&user_creds_method);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get default user method: %s", err_msg);
- return FALSE;
- }
-
- ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get client credential: %s", err_msg);
- return FALSE;
- }
-
- BT_DBG("client_creds: %s", client_creds);
-
- ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get user credential: %s", err_msg);
- if (client_creds)
- free(client_creds);
- return FALSE;
- }
-
- BT_DBG("user_creds: %s", user_creds);
-
- switch (function_name) {
- case BT_SET_LOCAL_NAME:
- case BT_START_DISCOVERY:
- case BT_START_CUSTOM_DISCOVERY:
- case BT_CANCEL_DISCOVERY:
- case BT_OOB_ADD_REMOTE_DATA:
- case BT_OOB_REMOVE_REMOTE_DATA:
- case BT_SET_ADVERTISING:
- case BT_SET_CUSTOM_ADVERTISING:
- case BT_SET_ADVERTISING_PARAMETERS:
- case BT_START_LE_DISCOVERY:
- case BT_STOP_LE_DISCOVERY:
-
- case BT_BOND_DEVICE:
- case BT_CANCEL_BONDING:
- case BT_UNBOND_DEVICE:
- case BT_SET_ALIAS:
- case BT_SET_AUTHORIZATION:
- case BT_UNSET_AUTHORIZATION:
- case BT_SEARCH_SERVICE:
-
- case BT_RFCOMM_CLIENT_CONNECT:
- case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
- case BT_RFCOMM_SOCKET_DISCONNECT:
- case BT_RFCOMM_SOCKET_WRITE:
- case BT_RFCOMM_CREATE_SOCKET:
- case BT_RFCOMM_REMOVE_SOCKET:
-
- case BT_OPP_PUSH_FILES:
- case BT_OPP_CANCEL_PUSH:
-
- case BT_OBEX_SERVER_ACCEPT_CONNECTION:
- case BT_OBEX_SERVER_REJECT_CONNECTION:
- case BT_OBEX_SERVER_ACCEPT_FILE:
- case BT_OBEX_SERVER_REJECT_FILE:
- case BT_OBEX_SERVER_SET_PATH:
- case BT_OBEX_SERVER_SET_ROOT:
- case BT_OBEX_SERVER_CANCEL_TRANSFER:
- case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
-
- case BT_AUDIO_CONNECT:
- case BT_AUDIO_DISCONNECT:
- case BT_AG_CONNECT:
- case BT_AG_DISCONNECT:
- case BT_AV_CONNECT:
- case BT_AV_DISCONNECT:
- case BT_AV_SOURCE_CONNECT:
- case BT_AV_SOURCE_DISCONNECT:
- case BT_AVRCP_CONTROL_CONNECT:
- case BT_AVRCP_CONTROL_DISCONNECT:
- case BT_AVRCP_HANDLE_CONTROL:
- case BT_AVRCP_SET_TRACK_INFO:
- case BT_AVRCP_SET_PROPERTY:
- case BT_AVRCP_SET_PROPERTIES:
- case BT_AVRCP_CONTROL_SET_PROPERTY:
-
- case BT_HF_CONNECT:
- case BT_HF_DISCONNECT:
-
- case BT_HID_CONNECT:
- case BT_HID_DISCONNECT:
-
- case BT_HID_DEVICE_ACTIVATE:
- case BT_HID_DEVICE_DEACTIVATE:
- case BT_HID_DEVICE_CONNECT:
- case BT_HID_DEVICE_DISCONNECT:
- case BT_HID_DEVICE_SEND_MOUSE_EVENT:
- case BT_HID_DEVICE_SEND_KEY_EVENT:
- case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
-
- case BT_CONNECT_LE:
- case BT_DISCONNECT_LE:
-
- case BT_SET_ADVERTISING_DATA:
- case BT_SET_SCAN_RESPONSE_DATA:
-
- case BT_HDP_CONNECT:
- case BT_HDP_DISCONNECT:
- case BT_HDP_SEND_DATA:
-
- case BT_DPM_SET_ALLOW_BT_MODE:
- case BT_DPM_GET_ALLOW_BT_MODE:
- case BT_DPM_SET_DEVICE_RESTRITION:
- case BT_DPM_GET_DEVICE_RESTRITION:
- case BT_DPM_SET_UUID_RESTRITION:
- case BT_DPM_GET_UUID_RESTRITION:
- case BT_DPM_ADD_DEVICES_BLACKLIST:
- case BT_DPM_ADD_DEVICES_WHITELIST:
- case BT_DPM_ADD_UUIDS_BLACKLIST:
- case BT_DPM_ADD_UUIDS_WHITELIST:
- case BT_DPM_CLEAR_DEVICES_BLACKLIST:
- case BT_DPM_CLEAR_DEVICES_WHITELIST:
- case BT_DPM_CLEAR_UUIDS_BLACKLIST:
- case BT_DPM_CLEAR_UUIDS_WHITELIST:
- case BT_DPM_REMOVE_DEVICE_BLACKLIST:
- case BT_DPM_REMOVE_DEVICE_WHITELIST:
- case BT_DPM_REMOVE_UUID_BLACKLIST:
- case BT_DPM_REMOVE_UUID_WHITELIST:
- case BT_DPM_GET_DEVICES_BLACKLIST:
- case BT_DPM_GET_DEVICES_WHITELIST:
- case BT_DPM_GET_UUIDS_BLACKLIST:
- case BT_DPM_GET_UUIDS_WHITELIST:
- case BT_DPM_SET_ALLOW_OUTGOING_CALL:
- case BT_DPM_GET_ALLOW_OUTGOING_CALL:
- case BT_DPM_SET_PAIRING_STATE:
- case BT_DPM_GET_PAIRING_STATE:
- case BT_DPM_SET_PROFILE_STATE:
- case BT_DPM_GET_PROFILE_STATE:
- case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
- case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
- case BT_DPM_SET_DISCOVERABLE_STATE:
- case BT_DPM_GET_DISCOVERABLE_STATE:
- case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
- case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
- case BT_DPM_SET_DATA_TRANSFER_STATE:
- case BT_DPM_GET_DATA_TRANSFER_STATE:
-
- case BT_NETWORK_ACTIVATE:
- case BT_NETWORK_DEACTIVATE:
- case BT_NETWORK_CONNECT:
- case BT_NETWORK_DISCONNECT:
- case BT_NETWORK_SERVER_DISCONNECT:
-
- case BT_GATT_GET_PRIMARY_SERVICES:
- case BT_GATT_DISCOVER_CHARACTERISTICS:
- case BT_GATT_SET_PROPERTY_REQUEST:
- case BT_GATT_READ_CHARACTERISTIC:
- case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
- case BT_GATT_REGISTER_APPLICATION:
- case BT_GATT_REGISTER_SERVICE:
- case BT_GATT_SEND_RESPONSE:
- case BT_PBAP_CONNECT:
- case BT_PBAP_DISCONNECT:
- case BT_PBAP_GET_PHONEBOOK_SIZE:
- case BT_PBAP_GET_PHONEBOOK:
- case BT_PBAP_GET_LIST:
- case BT_PBAP_PULL_VCARD:
- case BT_PBAP_PHONEBOOK_SEARCH:
-
- ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
- BT_PRIVILEGE_PUBLIC);
-
- if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
- BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
- result = FALSE;
- }
-
- /* Need to check mediastorage privilege */
- if (function_name == BT_PBAP_GET_PHONEBOOK ||
- function_name == BT_PBAP_PULL_VCARD) {
- ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
- MEDIASTORAGE_PRIVILEGE);
-
- if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
- BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
- result = FALSE;
- }
- }
- break;
-
- case BT_ENABLE_ADAPTER:
- case BT_DISABLE_ADAPTER:
- case BT_RESET_ADAPTER:
- case BT_RECOVER_ADAPTER:
- case BT_ENABLE_ADAPTER_LE:
- case BT_DISABLE_ADAPTER_LE:
- case BT_SET_CONNECTABLE:
- case BT_SET_DISCOVERABLE_MODE:
- case BT_ADD_WHITE_LIST:
- case BT_REMOVE_WHITE_LIST:
- case BT_CLEAR_WHITE_LIST:
- case BT_SET_MANUFACTURER_DATA:
- case BT_SET_SCAN_PARAMETERS:
-
- case BT_CANCEL_SEARCH_SERVICE:
- case BT_ENABLE_RSSI:
-
- case BT_RFCOMM_ACCEPT_CONNECTION:
- case BT_RFCOMM_REJECT_CONNECTION:
- case BT_RFCOMM_LISTEN:
-
- case BT_AVRCP_CONTROL_GET_PROPERTY:
- case BT_AVRCP_GET_TRACK_INFO:
-
- case BT_SET_CONTENT_PROTECT:
- case BT_BOND_DEVICE_BY_TYPE:
- case BT_SET_LE_PRIVACY:
- case BT_LE_CONN_UPDATE:
- case BT_LE_READ_MAXIMUM_DATA_LENGTH:
- case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
- case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
- case BT_LE_SET_DATA_LENGTH:
-
- case BT_LE_IPSP_INIT:
- case BT_LE_IPSP_DEINIT:
- case BT_LE_IPSP_CONNECT:
- case BT_LE_IPSP_DISCONNECT:
- ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
- BT_PRIVILEGE_PLATFORM);
-
- if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
- BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
- result = FALSE;
- }
- break;
-
- case BT_CHECK_ADAPTER:
- case BT_GET_RSSI:
-
- case BT_GET_LOCAL_NAME:
- case BT_GET_LOCAL_ADDRESS:
- case BT_GET_LOCAL_VERSION:
- case BT_IS_SERVICE_USED:
- case BT_GET_DISCOVERABLE_MODE:
- case BT_GET_DISCOVERABLE_TIME:
- case BT_IS_DISCOVERYING:
- case BT_IS_LE_DISCOVERYING:
- case BT_IS_CONNECTABLE:
- case BT_GET_BONDED_DEVICES:
- case BT_GET_BONDED_DEVICE:
- case BT_IS_DEVICE_CONNECTED:
- case BT_GET_SPEAKER_GAIN:
- case BT_SET_SPEAKER_GAIN:
- case BT_OOB_READ_LOCAL_DATA:
- case BT_RFCOMM_CLIENT_IS_CONNECTED:
- case BT_RFCOMM_IS_UUID_AVAILABLE:
- case BT_GET_ADVERTISING_DATA:
- case BT_GET_SCAN_RESPONSE_DATA:
- case BT_IS_ADVERTISING:
-
- case BT_OBEX_SERVER_ALLOCATE:
- case BT_OBEX_SERVER_DEALLOCATE:
- /* Non-privilege control */
- break;
- default:
- BT_ERR("Unknown function!");
- result = FALSE;
- break;
- }
-
- if (client_creds)
- free(client_creds);
-
- if (user_creds)
- free(user_creds);
-
- return result;
+ int ret_val;
+ gboolean result = TRUE;
+ char *client_creds = NULL;
+ char *user_creds = NULL;
+ 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, };
+
+ retv_if(unique_name == NULL, FALSE);
+
+ BT_DBG("unique_name: %s", unique_name);
+
+ retv_if(bt_service_conn == NULL, FALSE);
+
+ ret_val = cynara_creds_get_default_client_method(&client_creds_method);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get default client method: %s", err_msg);
+ return FALSE;
+ }
+
+ ret_val = cynara_creds_get_default_user_method(&user_creds_method);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get default user method: %s", err_msg);
+ return FALSE;
+ }
+
+ ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get client credential: %s", err_msg);
+ return FALSE;
+ }
+
+ BT_DBG("client_creds: %s", client_creds);
+
+ ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get user credential: %s", err_msg);
+
+ if (client_creds)
+ free(client_creds);
+ return FALSE;
+ }
+
+ BT_DBG("user_creds: %s", user_creds);
+
+ switch (function_name) {
+ case BT_SET_LOCAL_NAME:
+ case BT_START_DISCOVERY:
+ case BT_START_CUSTOM_DISCOVERY:
+ case BT_CANCEL_DISCOVERY:
+ case BT_OOB_ADD_REMOTE_DATA:
+ case BT_OOB_REMOVE_REMOTE_DATA:
+ case BT_SET_ADVERTISING:
+ case BT_SET_CUSTOM_ADVERTISING:
+ case BT_SET_ADVERTISING_PARAMETERS:
+ case BT_START_LE_DISCOVERY:
+ case BT_STOP_LE_DISCOVERY:
+
+ case BT_BOND_DEVICE:
+ case BT_CANCEL_BONDING:
+ case BT_UNBOND_DEVICE:
+ case BT_SET_ALIAS:
+ case BT_SET_AUTHORIZATION:
+ case BT_UNSET_AUTHORIZATION:
+ case BT_SEARCH_SERVICE:
+
+ case BT_RFCOMM_CLIENT_CONNECT:
+ case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
+ case BT_RFCOMM_SOCKET_DISCONNECT:
+ case BT_RFCOMM_SOCKET_WRITE:
+ case BT_RFCOMM_CREATE_SOCKET:
+ case BT_RFCOMM_REMOVE_SOCKET:
+
+ case BT_OPP_PUSH_FILES:
+ case BT_OPP_CANCEL_PUSH:
+
+ case BT_OBEX_SERVER_ACCEPT_CONNECTION:
+ case BT_OBEX_SERVER_REJECT_CONNECTION:
+ case BT_OBEX_SERVER_ACCEPT_FILE:
+ case BT_OBEX_SERVER_REJECT_FILE:
+ case BT_OBEX_SERVER_SET_PATH:
+ case BT_OBEX_SERVER_SET_ROOT:
+ case BT_OBEX_SERVER_CANCEL_TRANSFER:
+ case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
+
+ case BT_AUDIO_CONNECT:
+ case BT_AUDIO_DISCONNECT:
+ case BT_AG_CONNECT:
+ case BT_AG_DISCONNECT:
+ case BT_AV_CONNECT:
+ case BT_AV_DISCONNECT:
+ case BT_AV_SOURCE_CONNECT:
+ case BT_AV_SOURCE_DISCONNECT:
+ case BT_AVRCP_CONTROL_CONNECT:
+ case BT_AVRCP_CONTROL_DISCONNECT:
+ case BT_AVRCP_HANDLE_CONTROL:
+ case BT_AVRCP_SET_TRACK_INFO:
+ case BT_AVRCP_SET_PROPERTY:
+ case BT_AVRCP_SET_PROPERTIES:
+ case BT_AVRCP_CONTROL_SET_PROPERTY:
+
+ case BT_HF_CONNECT:
+ case BT_HF_DISCONNECT:
+
+ case BT_HID_CONNECT:
+ case BT_HID_DISCONNECT:
+
+ case BT_HID_DEVICE_ACTIVATE:
+ case BT_HID_DEVICE_DEACTIVATE:
+ case BT_HID_DEVICE_CONNECT:
+ case BT_HID_DEVICE_DISCONNECT:
+ case BT_HID_DEVICE_SEND_MOUSE_EVENT:
+ case BT_HID_DEVICE_SEND_KEY_EVENT:
+ case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
+
+ case BT_CONNECT_LE:
+ case BT_DISCONNECT_LE:
+
+ case BT_SET_ADVERTISING_DATA:
+ case BT_SET_SCAN_RESPONSE_DATA:
+
+ case BT_HDP_CONNECT:
+ case BT_HDP_DISCONNECT:
+ case BT_HDP_SEND_DATA:
+
+ case BT_DPM_SET_ALLOW_BT_MODE:
+ case BT_DPM_GET_ALLOW_BT_MODE:
+ case BT_DPM_SET_DEVICE_RESTRITION:
+ case BT_DPM_GET_DEVICE_RESTRITION:
+ case BT_DPM_SET_UUID_RESTRITION:
+ case BT_DPM_GET_UUID_RESTRITION:
+ case BT_DPM_ADD_DEVICES_BLACKLIST:
+ case BT_DPM_ADD_DEVICES_WHITELIST:
+ case BT_DPM_ADD_UUIDS_BLACKLIST:
+ case BT_DPM_ADD_UUIDS_WHITELIST:
+ case BT_DPM_CLEAR_DEVICES_BLACKLIST:
+ case BT_DPM_CLEAR_DEVICES_WHITELIST:
+ case BT_DPM_CLEAR_UUIDS_BLACKLIST:
+ case BT_DPM_CLEAR_UUIDS_WHITELIST:
+ case BT_DPM_REMOVE_DEVICE_BLACKLIST:
+ case BT_DPM_REMOVE_DEVICE_WHITELIST:
+ case BT_DPM_REMOVE_UUID_BLACKLIST:
+ case BT_DPM_REMOVE_UUID_WHITELIST:
+ case BT_DPM_GET_DEVICES_BLACKLIST:
+ case BT_DPM_GET_DEVICES_WHITELIST:
+ case BT_DPM_GET_UUIDS_BLACKLIST:
+ case BT_DPM_GET_UUIDS_WHITELIST:
+ case BT_DPM_SET_ALLOW_OUTGOING_CALL:
+ case BT_DPM_GET_ALLOW_OUTGOING_CALL:
+ case BT_DPM_SET_PAIRING_STATE:
+ case BT_DPM_GET_PAIRING_STATE:
+ case BT_DPM_SET_PROFILE_STATE:
+ case BT_DPM_GET_PROFILE_STATE:
+ case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
+ case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
+ case BT_DPM_SET_DISCOVERABLE_STATE:
+ case BT_DPM_GET_DISCOVERABLE_STATE:
+ case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
+ case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
+ case BT_DPM_SET_DATA_TRANSFER_STATE:
+ case BT_DPM_GET_DATA_TRANSFER_STATE:
+
+ case BT_NETWORK_ACTIVATE:
+ case BT_NETWORK_DEACTIVATE:
+ case BT_NETWORK_CONNECT:
+ case BT_NETWORK_DISCONNECT:
+ case BT_NETWORK_SERVER_DISCONNECT:
+
+ case BT_GATT_GET_PRIMARY_SERVICES:
+ case BT_GATT_DISCOVER_CHARACTERISTICS:
+ case BT_GATT_SET_PROPERTY_REQUEST:
+ case BT_GATT_READ_CHARACTERISTIC:
+ case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
+ case BT_GATT_REGISTER_APPLICATION:
+ case BT_GATT_REGISTER_SERVICE:
+ case BT_GATT_SEND_RESPONSE:
+ case BT_PBAP_CONNECT:
+ case BT_PBAP_DISCONNECT:
+ case BT_PBAP_GET_PHONEBOOK_SIZE:
+ case BT_PBAP_GET_PHONEBOOK:
+ case BT_PBAP_GET_LIST:
+ case BT_PBAP_PULL_VCARD:
+ case BT_PBAP_PHONEBOOK_SEARCH:
+
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ BT_PRIVILEGE_PUBLIC);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
+ result = FALSE;
+ }
+
+ /* Need to check mediastorage privilege */
+ if (function_name == BT_PBAP_GET_PHONEBOOK ||
+ function_name == BT_PBAP_PULL_VCARD) {
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ MEDIASTORAGE_PRIVILEGE);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
+ result = FALSE;
+ }
+ }
+break;
+
+ case BT_ENABLE_ADAPTER:
+ case BT_DISABLE_ADAPTER:
+ case BT_RESET_ADAPTER:
+ case BT_RECOVER_ADAPTER:
+ case BT_ENABLE_ADAPTER_LE:
+ case BT_DISABLE_ADAPTER_LE:
+ case BT_SET_CONNECTABLE:
+ case BT_SET_DISCOVERABLE_MODE:
+ case BT_ADD_WHITE_LIST:
+ case BT_REMOVE_WHITE_LIST:
+ case BT_CLEAR_WHITE_LIST:
+ case BT_SET_MANUFACTURER_DATA:
+ case BT_SET_SCAN_PARAMETERS:
+
+ case BT_CANCEL_SEARCH_SERVICE:
+ case BT_ENABLE_RSSI:
+
+ case BT_RFCOMM_ACCEPT_CONNECTION:
+ case BT_RFCOMM_REJECT_CONNECTION:
+ case BT_RFCOMM_LISTEN:
+
+ case BT_AVRCP_CONTROL_GET_PROPERTY:
+ case BT_AVRCP_GET_TRACK_INFO:
+
+ case BT_SET_CONTENT_PROTECT:
+ case BT_BOND_DEVICE_BY_TYPE:
+ case BT_SET_LE_PRIVACY:
+ case BT_LE_CONN_UPDATE:
+ case BT_LE_READ_MAXIMUM_DATA_LENGTH:
+ case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
+ case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
+ case BT_LE_SET_DATA_LENGTH:
+
+ case BT_LE_IPSP_INIT:
+ case BT_LE_IPSP_DEINIT:
+ case BT_LE_IPSP_CONNECT:
+ case BT_LE_IPSP_DISCONNECT:
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ BT_PRIVILEGE_PLATFORM);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
+ result = FALSE;
+ }
+ break;
+
+ case BT_CHECK_ADAPTER:
+ case BT_GET_RSSI:
+
+ case BT_GET_LOCAL_NAME:
+ case BT_GET_LOCAL_ADDRESS:
+ case BT_GET_LOCAL_VERSION:
+ case BT_IS_SERVICE_USED:
+ case BT_GET_DISCOVERABLE_MODE:
+ case BT_GET_DISCOVERABLE_TIME:
+ case BT_IS_DISCOVERYING:
+ case BT_IS_LE_DISCOVERYING:
+ case BT_IS_CONNECTABLE:
+ case BT_GET_BONDED_DEVICES:
+ case BT_GET_BONDED_DEVICE:
+ case BT_IS_DEVICE_CONNECTED:
+ case BT_GET_SPEAKER_GAIN:
+ case BT_SET_SPEAKER_GAIN:
+ case BT_OOB_READ_LOCAL_DATA:
+ case BT_RFCOMM_CLIENT_IS_CONNECTED:
+ case BT_RFCOMM_IS_UUID_AVAILABLE:
+ case BT_GET_ADVERTISING_DATA:
+ case BT_GET_SCAN_RESPONSE_DATA:
+ case BT_IS_ADVERTISING:
+
+ case BT_OBEX_SERVER_ALLOCATE:
+ case BT_OBEX_SERVER_DEALLOCATE:
+ /* Non-privilege control */
+ break;
+ default:
+ BT_ERR("Unknown function!");
+ result = FALSE;
+ break;
+ }
+
+ if (client_creds)
+ free(client_creds);
+
+ if (user_creds)
+ free(user_creds);
+
+ return result;
}
GDBusNodeInfo *__bt_service_create_method_node_info
int _bt_service_cynara_init(void)
{
- int result;
- char err_msg[256] = {0, };
+ int result;
+ char err_msg[256] = {0, };
- retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
+ retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
- result = cynara_initialize(&p_cynara, conf);
+ result = cynara_initialize(&p_cynara, conf);
- if (result != CYNARA_API_SUCCESS) {
- cynara_strerror(result, err_msg, sizeof(err_msg));
- BT_ERR("Fail to initialize cynara: [%s]", err_msg);
- return BLUETOOTH_ERROR_INTERNAL;
- }
+ if (result != CYNARA_API_SUCCESS) {
+ cynara_strerror(result, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to initialize cynara: [%s]", err_msg);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- return BLUETOOTH_ERROR_NONE;
+ return BLUETOOTH_ERROR_NONE;
}
void _bt_service_cynara_deinit(void)
{
- int result;
- char err_msg[256] = {0, };
+ int result;
+ char err_msg[256] = {0, };
- ret_if(p_cynara == NULL);
+ ret_if(p_cynara == NULL);
- result = cynara_finish(p_cynara);
+ result = cynara_finish(p_cynara);
- if (result != CYNARA_API_SUCCESS) {
- cynara_strerror(result, err_msg, sizeof(err_msg));
- BT_ERR("Fail to finish cynara: [%s]", err_msg);
- return;
- }
+ if (result != CYNARA_API_SUCCESS) {
+ cynara_strerror(result, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to finish cynara: [%s]", err_msg);
+ return;
+ }
- p_cynara = NULL;
- conf = NULL;
+ p_cynara = NULL;
+ conf = NULL;
}
visible_timer.event_id = 0;
visible_timer.timeout = 0;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
BT_ERR("Set vconf failed\n");
#endif
visible_timer.event_id = 0;
visible_timer.timeout = 0;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
BT_ERR("Set vconf failed\n");
#endif
visible_timer.timeout = timeout;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
BT_ERR("Set vconf failed");
#endif
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';
+ if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
+ *ptr = '\0';
_bt_set_local_name(phone_name);
}
}
}
-#ifdef TIZEN_MOBILE
+#ifdef TIZEN_PROFILE_MOBILE
static void __bt_set_visible_mode(void)
{
int timeout = 0;
if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
- BT_ERR("Fail to get the timeout value");
+ BT_ERR("Fail to get the timeout value");
if (timeout == -1) {
if (_bt_set_discoverable_mode(
BT_DBG("+");
int result = BLUETOOTH_ERROR_NONE;
-#ifdef TIZEN_MOBILE
+#ifdef TIZEN_PROFILE_MOBILE
__bt_set_visible_mode();
#else
#ifdef TIZEN_TV
g_variant_new_int32(result));
}
-#if defined(TIZEN_BT_FLIGHTMODE_ENABLED) || (!defined(TIZEN_WEARABLE) && defined(ENABLE_TIZEN_2_4))
+#if defined(TIZEN_FEATURE_FLIGHTMODE_ENABLED) || (!defined(TIZEN_PROFILE_WEARABLE) && defined(ENABLE_TIZEN_2_4))
static void __bt_service_flight_ps_mode_cb(keynode_t *node, void *data)
{
gboolean flight_mode = FALSE;
{
BT_DBG("+");
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
BT_ERR("Unable to register key handler");
BT_DBG("Telephony is disabled");
#endif
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#ifdef ENABLE_TIZEN_2_4
if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
{
BT_DBG("+");
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb);
#endif
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#ifdef ENABLE_TIZEN_2_4
vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb);
ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
(vconf_callback_fn)__bt_phone_name_changed_cb);
- if (0 != ret) {
+ if (0 != ret)
BT_ERR("vconf_ignore_key_changed failed\n");
- }
_bt_reliable_terminate_service(NULL);
- if (eventsystem_unregister_event(status_reg_id) != ES_R_OK) {
+ if (eventsystem_unregister_event(status_reg_id) != ES_R_OK)
BT_ERR("Fail to unregister system event");
- }
_bt_delete_event_timer(BT_EVENT_TIMER_DISABLE);
{
BT_CHECK_PARAMETER(device_address, return);
BT_CHECK_PARAMETER(dev_info, return);
-
- /* Should implement this */
+ /* Should implement this */
return BLUETOOTH_ERROR_NONE;
}
{
GDBusConnection *g_conn;
- if (system_conn == NULL) {
+ if (system_conn == NULL)
g_conn = __bt_init_system_gconn();
- } else {
+ else
g_conn = system_conn;
- }
retv_if(g_conn == NULL, NULL);
dev_addr += 4;
g_strlcpy(address, dev_addr, sizeof(address));
- while ((pos = strchr(address, '_')) != NULL) {
+ while ((pos = strchr(address, '_')) != NULL)
*pos = ':';
- }
g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
}
void _bt_convert_addr_string_to_type(unsigned char *addr,
const char *address)
{
- int i;
- char *ptr = NULL;
+ int i;
+ char *ptr = NULL;
ret_if(address == NULL);
ret_if(addr == NULL);
- for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
- addr[i] = strtol(address, &ptr, 16);
- if (ptr[0] != '\0') {
- if (ptr[0] != ':')
- return;
+ for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
+ addr[i] = strtol(address, &ptr, 16);
+ if (ptr[0] != '\0') {
+ if (ptr[0] != ':')
+ return;
- address = ptr + 1;
- }
- }
+ address = ptr + 1;
+ }
+ }
}
void _bt_convert_addr_type_to_string(char *address,
if (arg < 0)
return -errno;
- if (arg & O_NONBLOCK) {
+ if (arg & O_NONBLOCK)
BT_ERR("Already Non-blocking \n");
- }
arg |= O_NONBLOCK;
if (_bt_dpm_get_allow_bluetooth_mode() == DPM_BT_RESTRICTED)
return ret;
-
+
if (list) {
ret = DPM_RESULT_SUCCESS;
uuids_list.count = g_slist_length(policy_table[DPM_POLICY_BLUETOOTH_UUIDS_WHITELIST].list);
case BT_RFCOMM_SERVER_EVENT:
path = BT_RFCOMM_SERVER_PATH;
break;
- case BT_A2DP_SOURCE_EVENT:
- path = BT_A2DP_SOURCE_PATH;
- break;
+ case BT_A2DP_SOURCE_EVENT:
+ path = BT_A2DP_SOURCE_PATH;
+ break;
default:
BT_ERR("Unknown event");
return BLUETOOTH_ERROR_INTERNAL;
signal = BT_A2DP_SOURCE_CONNECTED;
BT_INFO_C("Connected [A2DP Source]");
break;
- case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
- signal = BT_A2DP_SOURCE_DISCONNECTED;
- BT_INFO_C("Disconnected [A2DP Source]");
- break;
+ case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
+ signal = BT_A2DP_SOURCE_DISCONNECTED;
+ BT_INFO_C("Disconnected [A2DP Source]");
+ break;
case BLUETOOTH_EVENT_AVRCP_CONNECTED:
case BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED:
signal = BT_AVRCP_CONNECTED;
case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
signal = BT_IPSP_DISCONNECTED;
break;
- case BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO:
- signal = BT_IPSP_BT_INTERFACE_INFO;
- break;
case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
signal = BT_GATT_CHAR_VAL_CHANGED;
break;
msg1 = g_dbus_message_new_signal(path, BT_EVENT_SERVICE, signal);
g_dbus_message_set_body(msg1, param);
- if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL)) {
+ if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL))
BT_ERR("Error while sending");
- }
g_object_unref(msg1);
path = BT_LE_ADAPTER_PATH;
break;
case BT_DEVICE_EVENT:
- path = BT_DEVICE_PATH;
+ path = BT_DEVICE_PATH;
break;
default:
BT_ERR("Unknown event");
BT_INFO_C("Terminating the bt-service daemon");
- if (main_loop != NULL) {
+ if (main_loop != NULL)
g_main_loop_quit(main_loop);
- } else {
+ else
exit(0);
- }
return FALSE;
}
#ifdef TIZEN_TV
_bt_enable_adapter();
#else
- if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
BT_DBG("no bluetooth device info, so BT was disabled at previous session");
- }
- if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0)
BT_ERR("no bluetooth le info, so BT LE was disabled at previous session");
- }
if ((bt_status != VCONFKEY_BT_STATUS_OFF) &&
(status == BT_DEACTIVATED)) {
g_main_loop_run(main_loop);
BT_DBG("g_main_loop_quit called!");
- if (main_loop != NULL) {
+ if (main_loop != NULL)
g_main_loop_unref(main_loop);
- }
if (terminated == FALSE)
__bt_release_service();
#define LOG_COLOR_PURPLE "\033[35m"
#define BT_DBG(fmt, args...) \
- SLOGD(fmt, ##args)
+ SLOGD(fmt, ##args)
#define BT_INFO(fmt, args...) \
- SLOGI(fmt, ##args)
+ SLOGI(fmt, ##args)
#define BT_ERR(fmt, args...) \
- SLOGE(fmt, ##args)
+ SLOGE(fmt, ##args)
#define BT_INFO_C(fmt, arg...) \
SLOGI_IF(TRUE, LOG_COLOR_GREEN" "fmt" "LOG_COLOR_RESET, ##arg)
/* UUID */
#define GENERIC_AUDIO_UUID "00001203-0000-1000-8000-00805f9b34fb"
-#define OBEX_OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
-
-#define HSP_HS_UUID "00001108-0000-1000-8000-00805f9b34fb"
-#define HSP_AG_UUID "00001112-0000-1000-8000-00805f9b34fb"
+#define AVRCP_TARGET_UUID "0000110c-0000-1000-8000-00805f9b34fb"
+#define AVRCP_REMOTE_UUID "0000110e-0000-1000-8000-00805f9b34fb"
+#define ADVANCED_AUDIO_UUID "0000110d-0000-1000-8000-00805f9b34fb"
+#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
+#define A2DP_SOURCE_UUID "0000110a-0000-1000-8000-00805f9b34fb"
#define HFP_HS_UUID "0000111e-0000-1000-8000-00805f9b34fb"
#define HFP_AG_UUID "0000111f-0000-1000-8000-00805f9b34fb"
-#define ADVANCED_AUDIO_UUID "0000110d-0000-1000-8000-00805f9b34fb"
-
-#define A2DP_SOURCE_UUID "0000110a-0000-1000-8000-00805f9b34fb"
-#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
-
-#define AVRCP_REMOTE_UUID "0000110e-0000-1000-8000-00805f9b34fb"
-#define AVRCP_TARGET_UUID "0000110c-0000-1000-8000-00805f9b34fb"
+#define HSP_HS_UUID "00001108-0000-1000-8000-00805f9b34fb"
+#define HSP_AG_UUID "00001112-0000-1000-8000-00805f9b34fb"
+#define RFCOMM_UUID_STR "00000003-0000-1000-8000-00805f9b34fb"
+#define HID_DEVICE_UUID "00001124-0000-1000-8000-00805f9b43bf"
#define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
+#define PANU_UUID "00001115-0000-1000-8000-00805f9b34fb"
+#define NAP_UUID "00001116-0000-1000-8000-00805f9b34fb"
#define PNP_UUID "00001200-0000-1000-8000-00805f9b34fb"
-#define RFCOMM_UUID_STR "00000003-0000-1000-8000-00805f9b34fb"
-#define PANU_UUID "00001115-0000-1000-8000-00805f9b34fb"
-#define NAP_UUID "00001116-0000-1000-8000-00805f9b34fb"
-#define OBEX_PSE_UUID "0000112f-0000-1000-8000-00805f9b34fb"
-#define GATT_UUID "00001801-0000-1000-8000-00805f9b34fb"
+#define PBAP_UUID "0000112f-0000-1000-8000-00805f9b34fb"
+
+#define OBEX_OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
+#define OBEX_PSE_UUID "0000112f-0000-1000-8000-00805f9b34fb"
+
+#define GATT_UUID "00001801-0000-1000-8000-00805f9b34fb"
/* Privilege */
#define BT_PRIVILEGE_PUBLIC "http://tizen.org/privilege/bluetooth"
BT_PROFILE_CONN_GATT = 0x40,
BT_PROGILE_CONN_NAP = 0x80,
BT_PROFILE_CONN_A2DP_SINK = 0x100,
+ BT_PROFILE_CONN_PBAP = 0x200,
BT_PROFILE_CONN_ALL = 0xffffffff,
} bt_profile_type_t;
#include "bluetooth-api.h"
#ifdef __cplusplus
- extern "C" {
+extern "C" {
#endif
* @brief DPM BT allowance state
* @see
*/
- typedef enum {
- DPM_BT_ERROR = -1, /**< bluetooth allowance error */
- DPM_BT_ALLOWED, /**< bluetooth allowance allowed */
- DPM_BT_HANDSFREE_ONLY, /**< bluetooth allowance handsfree only */
- DPM_BT_RESTRICTED, /**< bluetooth allowance restricted */
- } dpm_bt_allow_t;
+typedef enum {
+ DPM_BT_ERROR = -1, /**< bluetooth allowance error */
+ DPM_BT_ALLOWED, /**< bluetooth allowance allowed */
+ DPM_BT_HANDSFREE_ONLY, /**< bluetooth allowance handsfree only */
+ DPM_BT_RESTRICTED, /**< bluetooth allowance restricted */
+} dpm_bt_allow_t;
/**
* @brief DPM API result
int _bt_pbap_disconnect(const bluetooth_device_address_t *address);
+int _bt_pbap_is_connected(bluetooth_device_address_t *device_address,
+ gboolean *connected);
+
int _bt_pbap_get_phonebook_size(const bluetooth_device_address_t *address,
int source, int type);
bt-service-gap-agent.c
bt-service-pbap.c
bt-service-dpm.c
+bt-service-proximity.c
)
IF(LIBNOTIFY_SUPPORT)
storage
)
-IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_NETWORK_TETHERING_ENABLE")
+IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_FEATURE_NETWORK_TETHERING_ENABLE")
SET(PKG_MODULES ${PKG_MODULES}
capi-network-tethering
)
ADD_DEFINITIONS("-DHPS_FEATURE")
ADD_DEFINITIONS("-DTIZEN_DPM_ENABLE")
-IF(LIBNOTIFY_SUPPORT OR LIBNOTIFICATION_SUPPORT)
- ADD_DEFINITIONS("-DDATA_DIR_ICON=\"${SHARE_INSTALL_PREFIX}\"")
- MESSAGE("Icon used for notification is : ${SHARE_INSTALL_PREFIX}/icons/default/bt-icon.png")
-ENDIF(LIBNOTIFY_SUPPORT OR LIBNOTIFICATION_SUPPORT)
-
SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie")
ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${service_pkgs_LDFLAGS})
-# to permit usage of bluetooth_cancel_bonding in bt-popup.c. This build bluetooth-api first.
-IF(LIBNOTIFY_SUPPORT)
- ADD_DEPENDENCIES(${PROJECT_NAME} bluetooth-api)
- TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${service_pkgs_LDFLAGS} bluetooth-api)
-ELSE(LIBNOTIFY_SUPPORT)
- TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${service_pkgs_LDFLAGS})
-ENDIF(LIBNOTIFY_SUPPORT)
-
-#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/org.projectx.bt.service.in ${CMAKE_CURRENT_SOURCE_DIR}/org.projectx.bt.service)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/org.projectx.bt.service DESTINATION share/dbus-1/system-services)
INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
# install booting script
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf.in ${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf)
-IF (TIZEN_WEARABLE)
+IF (TIZEN_PROFILE_WEARABLE)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/wearable/stack_info DESTINATION /usr/etc/bluetooth/)
ELSE ()
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/mobile/stack_info DESTINATION /usr/etc/bluetooth/)
-ENDIF (TIZEN_WEARABLE)
+ENDIF (TIZEN_PROFILE_WEARABLE)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf DESTINATION /etc/dbus-1/system.d)
-AddressBlacklist=00:02:C7,00:16:FE,00:19:C1,00:1B:FB,00:1E:3D,00:21:4F,00:23:06,00:24:33,00:A0:79,00:0E:6D,00:13:E0,00:21:E8,00:60:57,00:0E:9F,00:12:1C,00:18:91,00:18:96,00:13:04,00:16:FD,00:22:A0,00:0B:4C,00:60:6F,00:23:3D,00:C0:59,00:0A:30,00:1E:AE,00:1C:D7,00:80:F0,00:12:8A,00:09:93,00:80:37,00:26:7E,00:1A:1B,00:14:9A,00:0B:24,08:76:95,00:14:09,00:1E:B2\r
-ExactNameBlacklist=Motorola IHF1000,i.TechBlueBAND,X5 Stereo v1.3,KML_CAN,SYNC,UConnect\r
-PartialNameBlacklist=BMW,Audi,Parrot,HandsFreeLink,Car,MB PhoneSystem,CAR MULTIMEDIA,MB Bluetooth,Pama\r
-KeyboardAutoPair=00:0F:F6\r
+AddressBlacklist=00:02:C7,00:16:FE,00:19:C1,00:1B:FB,00:1E:3D,00:21:4F,00:23:06,00:24:33,00:A0:79,00:0E:6D,00:13:E0,00:21:E8,00:60:57,00:0E:9F,00:12:1C,00:18:91,00:18:96,00:13:04,00:16:FD,00:22:A0,00:0B:4C,00:60:6F,00:23:3D,00:C0:59,00:0A:30,00:1E:AE,00:1C:D7,00:80:F0,00:12:8A,00:09:93,00:80:37,00:26:7E,08:76:95,00:1E:B2,00:26:E8,60:38:0E
+ExactNameBlacklist=Motorola IHF1000,i.TechBlueBAND,X5 Stereo v1.3,KML_CAN,SYNC,UConnect,Blue&Me
+PartialNameBlacklist=BMW,Audi,Parrot,HandsFreeLink,Car,MB PhoneSystem,CAR MULTIMEDIA,MB Bluetooth,Pama
+KeyboardAutoPair=00:0F:F6
#include "bt-request-handler.h"
#include "bt-service-pbap.h"
#include "bt-service-dpm.h"
+#include "bt-service-agent.h"
+#include "bt-service-proximity.h"
static GDBusConnection *bt_service_conn;
static guint owner_id = 0;
GDBusNodeInfo *node_info = NULL;
+static char *current_sender_playing = NULL;
+
static void __bt_service_method(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
GVariant *in_param2,
GVariant *in_param3,
GVariant *in_param4,
- GVariant *in_param5,
GArray **out_param1);
int __bt_agent_request(int function_name,
int request_type,
request_type, request_id,
invocation, param1,
param2, param3,
- param4, param5, &out_param1);
+ param4, &out_param1);
break;
case BT_AGENT_SERVICE:
result = __bt_agent_request(service_function,
goto fail;
}
- if (result != BLUETOOTH_ERROR_NONE) {
+ if (result != BLUETOOTH_ERROR_NONE)
goto fail;
- }
if ((request_type == BT_ASYNC_REQ ||
service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) &&
result = _bt_recover_adapter();
break;
case BT_ENABLE_ADAPTER_LE:
+ _bt_set_le_intended_status(TRUE);
result = _bt_enable_adapter_le();
break;
case BT_DISABLE_ADAPTER_LE:
+ _bt_set_le_intended_status(FALSE);
result = _bt_disable_adapter_le();
break;
case BT_RESET_ADAPTER:
break;
}
+ case BT_IS_SCAN_FILTER_SUPPORTED:{
+ int is_supported = 0;
+
+ if (_bt_is_scan_filter_supported() == TRUE)
+ is_supported = 1;
+
+ g_array_append_vals(*out_param1,
+ &is_supported, sizeof(int));
+
+ break;
+ }
case BT_ENABLE_RSSI: {
bluetooth_device_address_t bd_addr;
int link_type;
int length = 0;
result = _bt_get_advertising_data(&adv, &length);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
g_array_append_vals(*out_param1, adv.data, length);
- }
+
break;
}
case BT_SET_ADVERTISING_DATA: {
int length = 0;
result = _bt_get_scan_response_data(&rsp, &length);
- if (result == BLUETOOTH_ERROR_NONE) {
+ if (result == BLUETOOTH_ERROR_NONE)
g_array_append_vals(*out_param1, rsp.data, length);
- }
break;
}
result = _bt_get_bonded_devices(out_param1);
break;
}
+ case BT_GET_PROFILE_CONNECTED_DEVICES: {
+ char *uuid;
+ uuid = (char *)g_variant_get_data(in_param1);
+ result = _bt_get_profile_connected_devices(uuid, out_param1);
+ break;
+ }
+ case BT_SET_PASSKEY_NOTIFICATION: {
+ char *sender = NULL;
+ gboolean enable;
+
+ sender = (char *)g_dbus_method_invocation_get_sender(context);
+ __bt_service_get_parameters(in_param1,
+ &enable, sizeof(gboolean));
+
+ result = _bt_set_passkey_notification(sender, enable);
+ break;
+ }
case BT_GET_BONDED_DEVICE: {
bluetooth_device_address_t address = { {0} };
bluetooth_device_info_t dev_info;
}
break;
}
+ case BT_GET_IS_ALIAS_SET: {
+ bluetooth_device_address_t address = { {0} };
+ gboolean is_alias_set = FALSE;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_is_alias_set(&address, &is_alias_set);
+ if (result == BLUETOOTH_ERROR_NONE)
+ g_array_append_vals(*out_param1, &is_alias_set, sizeof(gboolean));
+
+ break;
+ }
case BT_BOND_DEVICE: {
bluetooth_device_address_t address = { {0} };
break;
}
+ case BT_SET_PROFILE_TRUSTED: {
+ bluetooth_device_address_t bd_addr = { {0} };
+ int profile;
+ int trust;
+
+ __bt_service_get_parameters(in_param1, &bd_addr,
+ sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2, &profile, sizeof(int));
+ __bt_service_get_parameters(in_param3, &trust, sizeof(int));
+
+ result = _bt_set_trust_profile(&bd_addr, profile, trust);
+ break;
+ }
+ case BT_GET_PROFILE_TRUSTED: {
+ bluetooth_device_address_t bd_addr = { {0} };
+ int profile;
+ guint trusted_profile = 0;
+
+ __bt_service_get_parameters(in_param1, &bd_addr,
+ sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2, &profile, sizeof(int));
+
+ result = _bt_get_trust_profile(&bd_addr, profile, &trusted_profile);
+ BT_DBG("TRUST %d", trusted_profile);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &trusted_profile,
+ sizeof(guint));
+ }
+
+ break;
+ }
+ case BT_SET_PROFILE_RESTRICTED: {
+ bluetooth_device_address_t bd_addr = { {0} };
+ int profile;
+ int restricted;
+
+ __bt_service_get_parameters(in_param1, &bd_addr,
+ sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2, &profile, sizeof(int));
+ __bt_service_get_parameters(in_param3, &restricted, sizeof(int));
+
+ result = _bt_set_restrict_profile(&bd_addr, profile, restricted);
+ break;
+ }
+ case BT_GET_PROFILE_RESTRICTED: {
+ bluetooth_device_address_t bd_addr = { {0} };
+ int profile;
+ guint restricted_profile = 0;
+
+ __bt_service_get_parameters(in_param1, &bd_addr,
+ sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2, &profile, sizeof(int));
+
+ result = _bt_get_restrict_profile(&bd_addr, profile, &restricted_profile);
+ BT_DBG("Restricted %d", restricted_profile);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &restricted_profile,
+ sizeof(guint));
+ }
+
+ break;
+ }
case BT_HID_CONNECT: {
bluetooth_device_address_t address = { {0} };
}
break;
}
+ case BT_HID_ENABLE_BARCODE_FEATURE: {
+ result = _bt_hid_enable_barcode_feature();
+ break;
+ }
case BT_NETWORK_ACTIVATE:
result = _bt_network_activate();
break;
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_connect(request_id, BT_AUDIO_ALL,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AUDIO_DISCONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_disconnect(request_id, BT_AUDIO_ALL,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AG_CONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_connect(request_id, BT_AUDIO_HSP,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AG_DISCONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_disconnect(request_id, BT_AUDIO_HSP,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AV_CONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_connect(request_id, BT_AUDIO_A2DP,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AV_DISCONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AVRCP_CONTROL_CONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_connect(request_id, BT_AVRCP,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AVRCP_CONTROL_DISCONNECT: {
&address, sizeof(bluetooth_device_address_t));
result = _bt_audio_disconnect(request_id, BT_AVRCP,
- &address, out_param1);
+ &address, *out_param1);
break;
}
+ case BT_AVRCP_TARGET_CONNECT: {
+ bluetooth_device_address_t address = { {0} };
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ result = _bt_audio_connect(request_id, BT_AVRCP_TARGET,
+ &address, *out_param1);
+ break;
+ }
+ case BT_AVRCP_TARGET_DISCONNECT: {
+ bluetooth_device_address_t address = { {0} };
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ result = _bt_audio_disconnect(request_id, BT_AVRCP_TARGET,
+ &address, *out_param1);
+ break;
+ }
case BT_AV_SOURCE_CONNECT: {
bluetooth_device_address_t address = { {0} };
sizeof(bluetooth_device_address_t));
result = _bt_audio_connect(request_id, BT_AUDIO_A2DP_SOURCE,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_AV_SOURCE_DISCONNECT: {
sizeof(bluetooth_device_address_t));
result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP_SOURCE,
- &address, out_param1);
+ &address, *out_param1);
break;
}
case BT_HF_CONNECT: {
__bt_service_get_parameters(in_param1,
&address, sizeof(bluetooth_device_address_t));
- result = _bt_hf_connect(request_id, &address, out_param1);
+ result = _bt_hf_connect(request_id, &address, *out_param1);
break;
}
case BT_HF_DISCONNECT: {
__bt_service_get_parameters(in_param1,
&address, sizeof(bluetooth_device_address_t));
- result = _bt_hf_disconnect(request_id, &address, out_param1);
+ result = _bt_hf_disconnect(request_id, &address, *out_param1);
break;
}
case BT_SET_CONTENT_PROTECT: {
}
case BT_OOB_ADD_REMOTE_DATA: {
bluetooth_device_address_t address = { {0} };
- bt_oob_data_t local_oob_data;
+ bt_oob_data_t remote_oob_data;
__bt_service_get_parameters(in_param1,
&address, sizeof(bluetooth_device_address_t));
__bt_service_get_parameters(in_param2,
- &local_oob_data, sizeof(bt_oob_data_t));
+ &remote_oob_data, sizeof(bt_oob_data_t));
- result = _bt_oob_add_remote_data(&address, &local_oob_data);
+ result = _bt_oob_add_remote_data(&address, &remote_oob_data);
break;
}
case BT_AVRCP_SET_PROPERTY: {
int type;
unsigned int value;
+ char *sender = NULL;
+ sender = (char *)g_dbus_method_invocation_get_sender(context);
+ BT_INFO("Sender %s", sender);
__bt_service_get_parameters(in_param1,
&type, sizeof(int));
__bt_service_get_parameters(in_param2,
&value, sizeof(unsigned int));
+ if (value == STATUS_PLAYING) {
+ if (current_sender_playing)
+ g_free(current_sender_playing);
+ current_sender_playing = g_strdup(sender);
+ }
+ if (g_strcmp0(sender, current_sender_playing) == 0 ||
+ current_sender_playing == NULL) {
+ BT_INFO("Current Player Status %d type %d", value, type);
+ } else {
+ BT_INFO("Current Player and this sender are different");
+ result = BLUETOOTH_ERROR_NONE;
+ break;
+ }
result = _bt_avrcp_set_property(type, value);
break;
__bt_service_get_parameters(in_param2,
&auto_connect, sizeof(gboolean));
- result = _bt_connect_le_device(request_id, &address, auto_connect);
+ result = _bt_connect_le_device(request_id, &address,
+ auto_connect);
if (result != BLUETOOTH_ERROR_NONE) {
g_array_append_vals(*out_param1, &address,
sizeof(bluetooth_device_address_t));
}
+
break;
}
case BT_DISCONNECT_LE: {
g_array_append_vals(*out_param1, &address,
sizeof(bluetooth_device_address_t));
}
+
break;
}
case BT_SET_LE_PRIVACY: {
break;
}
+ case BT_REQ_ATT_MTU: {
+ bluetooth_device_address_t address = { {0} };
+ unsigned int mtu;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2,
+ &mtu, sizeof(unsigned int));
+
+ result = _bt_request_att_mtu(request_id, &address, mtu);
+ if (result != BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &address,
+ sizeof(bluetooth_device_info_t));
+ }
+ break;
+ }
+ case BT_GET_ATT_MTU: {
+ bluetooth_device_address_t address = { {0} };
+ unsigned int mtu = 0;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_get_att_mtu(&address, &mtu);
+ BT_DBG("MTU: %d", mtu);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &mtu,
+ sizeof(unsigned int));
+ }
+ break;
+ }
+ case BT_GET_DEVICE_IDA: {
+ bluetooth_device_address_t address = { {0} };
+ bluetooth_device_address_t id_addr = { {0} };
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+
+ result = _bt_get_device_ida(&address, &id_addr);
+
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &id_addr,
+ sizeof(bluetooth_device_address_t));
+ }
+ break;
+ }
+ case BT_SET_LE_STATIC_RANDOM_ADDRESS: {
+ gboolean is_enable;
+
+ __bt_service_get_parameters(in_param1, &is_enable,
+ sizeof(gboolean));
+
+ result = _bt_set_le_static_random_address(is_enable);
+
+ break;
+ }
case BT_HDP_CONNECT:
case BT_HDP_DISCONNECT:
case BT_HDP_SEND_DATA:
break;
}
+ case BT_PXP_SET_PROPERTY: {
+ bluetooth_device_address_t address = { {0} };
+ unsigned int property = 0;
+ unsigned int value = 0;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2,
+ &property, sizeof(int));
+ __bt_service_get_parameters(in_param3,
+ &value, sizeof(int));
+
+ result = bt_set_proximity_property(&address, property, value);
+ break;
+ }
+ case BT_PXP_GET_PROPERTY: {
+ bluetooth_device_address_t address = { {0} };
+ unsigned int property = 0;
+ int value = 0;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+ __bt_service_get_parameters(in_param2,
+ &property, sizeof(unsigned int));
+
+ result = bt_get_proximity_property(&address, property, &value);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &value,
+ sizeof(int));
+ }
+ break;
+ }
+ case BT_PXP_GET_SUPPORTED_SERIVCES: {
+ bluetooth_device_address_t address = { {0} };
+ unsigned int property = 0;
+
+ __bt_service_get_parameters(in_param1,
+ &address, sizeof(bluetooth_device_address_t));
+
+ result = bt_get_proximity_supported_services(&address, &property);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ g_array_append_vals(*out_param1, &property,
+ sizeof(int));
+ }
+ break;
+ }
+ case BT_PXP_REGISTER_REPORTER: {
+ result = bt_register_proximity_reporter();
+ break;
+ }
+ case BT_PXP_UNREGISTER_REPORTER: {
+ result = bt_unregister_proximity_reporter();
+ break;
+ }
default:
result = BLUETOOTH_ERROR_INTERNAL;
break;
GVariant *in_param2,
GVariant *in_param3,
GVariant *in_param4,
- GVariant *in_param5,
GArray **out_param1)
{
BT_DBG("+");
bt_file_path_t path;
char **file_path;
int file_count;
- GDBusProxy *process_proxy;
- guint owner_pid = 0;
- int opp_server_pid = 0;
- const gchar *owner_sender_name = NULL;
- GDBusConnection *owner_connection = NULL;
- GVariant *val_get = NULL;
- GError *error_connection = NULL;
- GError *errro_proxy = NULL;
GArray *param2;
__bt_service_get_parameters(in_param1, &address,
path = g_array_index(param2, bt_file_path_t, i);
file_path[i] = g_strdup(path.path);
}
+ BT_DBG("_bt_opp_client_push_files");
+ result = _bt_opp_client_push_files(request_id, context,
+ &address, file_path,
+ file_count);
- owner_connection = g_dbus_method_invocation_get_connection(context);
- owner_sender_name = g_dbus_method_invocation_get_sender(context);
-
- BT_DBG("sender = %s", owner_sender_name);
-
- process_proxy = g_dbus_proxy_new_sync(owner_connection,
- G_DBUS_PROXY_FLAGS_NONE,
- NULL,
- "org.freedesktop.DBus",
- "/org/freedesktop/DBus",
- "org.freedesktop.DBus",
- NULL, &error_connection);
-
- if (process_proxy == NULL)
- BT_DBG("Fail to get process_proxy");
-
- if (error_connection) {
- BT_DBG("Fail to get proxy : %s", error_connection->message);
- g_error_free(error_connection);
- error_connection = NULL;
- }
-
- if (process_proxy) {
- val_get = g_dbus_proxy_call_sync(process_proxy,
- "GetConnectionUnixProcessID",
- g_variant_new("(s)", owner_sender_name),
- G_DBUS_CALL_FLAGS_NONE,
- -1, NULL,
- &errro_proxy);
-
- if (val_get == NULL) {
- BT_DBG("Fail to get pid");
- } else {
- g_variant_get(val_get, "(u)", &owner_pid);
- BT_DBG("request is from pid %d\n", owner_pid);
- }
-
- if (errro_proxy) {
- g_error("Unable to get PID for %s: %s",
- owner_sender_name, errro_proxy->message);
- g_error_free(errro_proxy);
- errro_proxy = NULL;
- }
- } else {
- BT_DBG("fail to get proxy");
- }
-
- opp_server_pid = _bt_obex_get_native_pid();
-
- BT_DBG("owner_pid, agent_info.native_server->app_pid = %d, %d",
- owner_pid, opp_server_pid);
- if (opp_server_pid == owner_pid) {
- BT_DBG("The exception case : _bt_opp_client_push_files");
- result = _bt_opp_client_push_files(request_id, context,
- &address, file_path,
- file_count);
- } else {
- BT_DBG("normal case");
- result = _bt_opp_client_push_files(request_id, context,
- &address, file_path,
- file_count);
- }
-
- for (i = 0; i < file_count; i++) {
+ for (i = 0; i < file_count; i++)
g_free(file_path[i]);
- }
+
g_free(file_path);
g_array_free(param2, TRUE);
- if (process_proxy)
- g_object_unref(process_proxy);
+
break;
}
case BT_OPP_CANCEL_PUSH: {
sizeof(gboolean));
break;
}
+ case BT_OPP_GET_TRANSFER_PROGRESS: {
+ int direction;
+ int transfer_id;
+ guint8 progress = 0;
+
+ __bt_service_get_parameters(in_param1, &direction,
+ sizeof(int));
+ __bt_service_get_parameters(in_param2, &transfer_id,
+ sizeof(int));
+ if (direction)
+ result = _bt_opp_get_client_progress(&progress);
+ else
+ result = _bt_opp_get_server_progress(transfer_id, &progress);
+
+ g_array_append_vals(*out_param1, &progress,
+ sizeof(guint8));
+
+ break;
+ }
case BT_OBEX_SERVER_ALLOCATE: {
int app_pid;
gboolean is_native;
sizeof(gboolean));
__bt_service_get_parameters(in_param3, &app_pid,
sizeof(int));
+
result = _bt_obex_server_allocate(sender,
path, app_pid, is_native);
char *file_name;
file_name = (char *)g_variant_get_data(in_param1);
+
result = _bt_obex_server_accept_authorize(file_name, TRUE);
break;
__bt_service_get_parameters(in_param2, &is_native,
sizeof(gboolean));
- result = _bt_obex_server_set_destination_path(
- destination_path, is_native);
+ result = _bt_obex_server_set_destination_path(destination_path,
+ is_native);
break;
}
int service_type,
const char *unique_name)
{
- int ret_val;
- gboolean result = TRUE;
- char *client_creds = NULL;
- char *user_creds = NULL;
- 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, };
-
- retv_if(unique_name == NULL, FALSE);
-
- BT_DBG("unique_name: %s", unique_name);
-
- retv_if(bt_service_conn == NULL, FALSE);
-
- ret_val = cynara_creds_get_default_client_method(&client_creds_method);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get default client method: %s", err_msg);
- return FALSE;
- }
-
- ret_val = cynara_creds_get_default_user_method(&user_creds_method);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get default user method: %s", err_msg);
- return FALSE;
- }
-
- ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get client credential: %s", err_msg);
- return FALSE;
- }
-
- BT_DBG("client_creds: %s", client_creds);
-
- ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
- if (ret_val != CYNARA_API_SUCCESS) {
- cynara_strerror(ret_val, err_msg, sizeof(err_msg));
- BT_ERR("Fail to get user credential: %s", err_msg);
- if (client_creds)
- free(client_creds);
- return FALSE;
- }
-
- BT_DBG("user_creds: %s", user_creds);
-
- switch (function_name) {
- case BT_SET_LOCAL_NAME:
- case BT_START_DISCOVERY:
- case BT_START_CUSTOM_DISCOVERY:
- case BT_CANCEL_DISCOVERY:
- case BT_OOB_ADD_REMOTE_DATA:
- case BT_OOB_REMOVE_REMOTE_DATA:
- case BT_SET_ADVERTISING:
- case BT_SET_CUSTOM_ADVERTISING:
- case BT_SET_ADVERTISING_PARAMETERS:
- case BT_START_LE_DISCOVERY:
- case BT_STOP_LE_DISCOVERY:
-
- case BT_BOND_DEVICE:
- case BT_CANCEL_BONDING:
- case BT_UNBOND_DEVICE:
- case BT_SET_ALIAS:
- case BT_SET_AUTHORIZATION:
- case BT_UNSET_AUTHORIZATION:
- case BT_SEARCH_SERVICE:
-
- case BT_RFCOMM_CLIENT_CONNECT:
- case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
- case BT_RFCOMM_SOCKET_DISCONNECT:
- case BT_RFCOMM_SOCKET_WRITE:
- case BT_RFCOMM_CREATE_SOCKET:
- case BT_RFCOMM_REMOVE_SOCKET:
-
- case BT_OPP_PUSH_FILES:
- case BT_OPP_CANCEL_PUSH:
-
- case BT_OBEX_SERVER_ACCEPT_CONNECTION:
- case BT_OBEX_SERVER_REJECT_CONNECTION:
- case BT_OBEX_SERVER_ACCEPT_FILE:
- case BT_OBEX_SERVER_REJECT_FILE:
- case BT_OBEX_SERVER_SET_PATH:
- case BT_OBEX_SERVER_SET_ROOT:
- case BT_OBEX_SERVER_CANCEL_TRANSFER:
- case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
-
- case BT_AUDIO_CONNECT:
- case BT_AUDIO_DISCONNECT:
- case BT_AG_CONNECT:
- case BT_AG_DISCONNECT:
- case BT_AV_CONNECT:
- case BT_AV_DISCONNECT:
- case BT_AV_SOURCE_CONNECT:
- case BT_AV_SOURCE_DISCONNECT:
- case BT_AVRCP_CONTROL_CONNECT:
- case BT_AVRCP_CONTROL_DISCONNECT:
- case BT_AVRCP_HANDLE_CONTROL:
- case BT_AVRCP_SET_TRACK_INFO:
- case BT_AVRCP_SET_PROPERTY:
- case BT_AVRCP_SET_PROPERTIES:
- case BT_AVRCP_CONTROL_SET_PROPERTY:
-
- case BT_HF_CONNECT:
- case BT_HF_DISCONNECT:
-
- case BT_HID_CONNECT:
- case BT_HID_DISCONNECT:
-
- case BT_HID_DEVICE_ACTIVATE:
- case BT_HID_DEVICE_DEACTIVATE:
- case BT_HID_DEVICE_CONNECT:
- case BT_HID_DEVICE_DISCONNECT:
- case BT_HID_DEVICE_SEND_MOUSE_EVENT:
- case BT_HID_DEVICE_SEND_KEY_EVENT:
- case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
-
- case BT_CONNECT_LE:
- case BT_DISCONNECT_LE:
-
- case BT_SET_ADVERTISING_DATA:
- case BT_SET_SCAN_RESPONSE_DATA:
-
- case BT_HDP_CONNECT:
- case BT_HDP_DISCONNECT:
- case BT_HDP_SEND_DATA:
- case BT_HDP_REGISTER_SINK_APP:
- case BT_HDP_UNREGISTER_SINK_APP:
-
- case BT_DPM_SET_ALLOW_BT_MODE:
- case BT_DPM_GET_ALLOW_BT_MODE:
- case BT_DPM_SET_DEVICE_RESTRITION:
- case BT_DPM_GET_DEVICE_RESTRITION:
- case BT_DPM_SET_UUID_RESTRITION:
- case BT_DPM_GET_UUID_RESTRITION:
- case BT_DPM_ADD_DEVICES_BLACKLIST:
- case BT_DPM_ADD_DEVICES_WHITELIST:
- case BT_DPM_ADD_UUIDS_BLACKLIST:
- case BT_DPM_ADD_UUIDS_WHITELIST:
- case BT_DPM_CLEAR_DEVICES_BLACKLIST:
- case BT_DPM_CLEAR_DEVICES_WHITELIST:
- case BT_DPM_CLEAR_UUIDS_BLACKLIST:
- case BT_DPM_CLEAR_UUIDS_WHITELIST:
- case BT_DPM_REMOVE_DEVICE_BLACKLIST:
- case BT_DPM_REMOVE_DEVICE_WHITELIST:
- case BT_DPM_REMOVE_UUID_BLACKLIST:
- case BT_DPM_REMOVE_UUID_WHITELIST:
- case BT_DPM_GET_DEVICES_BLACKLIST:
- case BT_DPM_GET_DEVICES_WHITELIST:
- case BT_DPM_GET_UUIDS_BLACKLIST:
- case BT_DPM_GET_UUIDS_WHITELIST:
- case BT_DPM_SET_ALLOW_OUTGOING_CALL:
- case BT_DPM_GET_ALLOW_OUTGOING_CALL:
- case BT_DPM_SET_PAIRING_STATE:
- case BT_DPM_GET_PAIRING_STATE:
- case BT_DPM_SET_PROFILE_STATE:
- case BT_DPM_GET_PROFILE_STATE:
- case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
- case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
- case BT_DPM_SET_DISCOVERABLE_STATE:
- case BT_DPM_GET_DISCOVERABLE_STATE:
- case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
- case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
- case BT_DPM_SET_DATA_TRANSFER_STATE:
- case BT_DPM_GET_DATA_TRANSFER_STATE:
-
- case BT_NETWORK_ACTIVATE:
- case BT_NETWORK_DEACTIVATE:
- case BT_NETWORK_CONNECT:
- case BT_NETWORK_DISCONNECT:
- case BT_NETWORK_SERVER_DISCONNECT:
-
- case BT_GATT_GET_PRIMARY_SERVICES:
- case BT_GATT_DISCOVER_CHARACTERISTICS:
- case BT_GATT_SET_PROPERTY_REQUEST:
- case BT_GATT_READ_CHARACTERISTIC:
- case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
- case BT_GATT_REGISTER_APPLICATION:
- case BT_GATT_REGISTER_SERVICE:
- case BT_GATT_SEND_RESPONSE:
- case BT_PBAP_CONNECT:
- case BT_PBAP_DISCONNECT:
- case BT_PBAP_GET_PHONEBOOK_SIZE:
- case BT_PBAP_GET_PHONEBOOK:
- case BT_PBAP_GET_LIST:
- case BT_PBAP_PULL_VCARD:
- case BT_PBAP_PHONEBOOK_SEARCH:
-
- ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
- BT_PRIVILEGE_PUBLIC);
-
- if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
- BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
- result = FALSE;
- }
-
- /* Need to check mediastorage privilege */
- if (function_name == BT_PBAP_GET_PHONEBOOK ||
- function_name == BT_PBAP_PULL_VCARD) {
- ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
- MEDIASTORAGE_PRIVILEGE);
-
- if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
- BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
- result = FALSE;
- }
- }
- break;
-
- case BT_ENABLE_ADAPTER:
- case BT_DISABLE_ADAPTER:
- case BT_RESET_ADAPTER:
- case BT_RECOVER_ADAPTER:
- case BT_ENABLE_ADAPTER_LE:
- case BT_DISABLE_ADAPTER_LE:
- case BT_SET_CONNECTABLE:
- case BT_SET_DISCOVERABLE_MODE:
- case BT_ADD_WHITE_LIST:
- case BT_REMOVE_WHITE_LIST:
- case BT_CLEAR_WHITE_LIST:
- case BT_SET_MANUFACTURER_DATA:
- case BT_SET_SCAN_PARAMETERS:
-
- case BT_CANCEL_SEARCH_SERVICE:
- case BT_ENABLE_RSSI:
-
- case BT_RFCOMM_ACCEPT_CONNECTION:
- case BT_RFCOMM_REJECT_CONNECTION:
- case BT_RFCOMM_LISTEN:
-
- case BT_AVRCP_CONTROL_GET_PROPERTY:
- case BT_AVRCP_GET_TRACK_INFO:
-
- case BT_SET_CONTENT_PROTECT:
- case BT_BOND_DEVICE_BY_TYPE:
- case BT_SET_LE_PRIVACY:
- case BT_LE_CONN_UPDATE:
- case BT_LE_READ_MAXIMUM_DATA_LENGTH:
- case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
- case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
- case BT_LE_SET_DATA_LENGTH:
-
- case BT_LE_IPSP_INIT:
- case BT_LE_IPSP_DEINIT:
- case BT_LE_IPSP_CONNECT:
- case BT_LE_IPSP_DISCONNECT:
- ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
- BT_PRIVILEGE_PLATFORM);
-
- if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
- BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
- result = FALSE;
- }
- break;
-
- case BT_CHECK_ADAPTER:
- case BT_GET_RSSI:
-
- case BT_GET_LOCAL_NAME:
- case BT_GET_LOCAL_ADDRESS:
- case BT_GET_LOCAL_VERSION:
- case BT_IS_SERVICE_USED:
- case BT_GET_DISCOVERABLE_MODE:
- case BT_GET_DISCOVERABLE_TIME:
- case BT_IS_DISCOVERYING:
- case BT_IS_LE_DISCOVERYING:
- case BT_IS_CONNECTABLE:
- case BT_GET_BONDED_DEVICES:
- case BT_GET_BONDED_DEVICE:
- case BT_IS_DEVICE_CONNECTED:
- case BT_GET_SPEAKER_GAIN:
- case BT_SET_SPEAKER_GAIN:
- case BT_OOB_READ_LOCAL_DATA:
- case BT_RFCOMM_CLIENT_IS_CONNECTED:
- case BT_RFCOMM_IS_UUID_AVAILABLE:
- case BT_GET_ADVERTISING_DATA:
- case BT_GET_SCAN_RESPONSE_DATA:
- case BT_IS_ADVERTISING:
-
- case BT_OBEX_SERVER_ALLOCATE:
- case BT_OBEX_SERVER_DEALLOCATE:
- /* Non-privilege control */
- break;
- default:
- BT_ERR("Unknown function!");
- result = FALSE;
- break;
- }
-
- if (client_creds)
- free(client_creds);
-
- if (user_creds)
- free(user_creds);
-
- return result;
+ int ret_val;
+ gboolean result = TRUE;
+ char *client_creds = NULL;
+ char *user_creds = NULL;
+ 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, };
+
+ retv_if(unique_name == NULL, FALSE);
+
+ BT_DBG("unique_name: %s", unique_name);
+
+ retv_if(bt_service_conn == NULL, FALSE);
+
+ ret_val = cynara_creds_get_default_client_method(&client_creds_method);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get default client method: %s", err_msg);
+ return FALSE;
+ }
+
+ ret_val = cynara_creds_get_default_user_method(&user_creds_method);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get default user method: %s", err_msg);
+ return FALSE;
+ }
+
+ ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get client credential: %s", err_msg);
+ return FALSE;
+ }
+
+ BT_DBG("client_creds: %s", client_creds);
+
+ ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get user credential: %s", err_msg);
+ if (client_creds)
+ free(client_creds);
+ return FALSE;
+ }
+
+ BT_DBG("user_creds: %s", user_creds);
+
+ switch (function_name) {
+ case BT_SET_LOCAL_NAME:
+ case BT_START_DISCOVERY:
+ case BT_START_CUSTOM_DISCOVERY:
+ case BT_CANCEL_DISCOVERY:
+ case BT_OOB_ADD_REMOTE_DATA:
+ case BT_OOB_REMOVE_REMOTE_DATA:
+ case BT_SET_ADVERTISING:
+ case BT_SET_CUSTOM_ADVERTISING:
+ case BT_SET_ADVERTISING_PARAMETERS:
+ case BT_START_LE_DISCOVERY:
+ case BT_STOP_LE_DISCOVERY:
+ case BT_SET_SCAN_PARAMETERS:
+
+ case BT_BOND_DEVICE:
+ case BT_CANCEL_BONDING:
+ case BT_UNBOND_DEVICE:
+ case BT_SET_ALIAS:
+ case BT_SET_AUTHORIZATION:
+ case BT_UNSET_AUTHORIZATION:
+ case BT_SEARCH_SERVICE:
+
+ case BT_RFCOMM_CLIENT_CONNECT:
+ case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
+ case BT_RFCOMM_SOCKET_DISCONNECT:
+ case BT_RFCOMM_SOCKET_WRITE:
+ case BT_RFCOMM_CREATE_SOCKET:
+ case BT_RFCOMM_REMOVE_SOCKET:
+
+ case BT_OPP_PUSH_FILES:
+ case BT_OPP_CANCEL_PUSH:
+
+ case BT_OBEX_SERVER_ACCEPT_CONNECTION:
+ case BT_OBEX_SERVER_REJECT_CONNECTION:
+ case BT_OBEX_SERVER_ACCEPT_FILE:
+ case BT_OBEX_SERVER_REJECT_FILE:
+ case BT_OBEX_SERVER_SET_PATH:
+ case BT_OBEX_SERVER_SET_ROOT:
+ case BT_OBEX_SERVER_CANCEL_TRANSFER:
+ case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
+
+ case BT_AUDIO_CONNECT:
+ case BT_AUDIO_DISCONNECT:
+ case BT_AG_CONNECT:
+ case BT_AG_DISCONNECT:
+ case BT_AV_CONNECT:
+ case BT_AV_DISCONNECT:
+ case BT_AV_SOURCE_CONNECT:
+ case BT_AV_SOURCE_DISCONNECT:
+ case BT_AVRCP_CONTROL_CONNECT:
+ case BT_AVRCP_CONTROL_DISCONNECT:
+ case BT_AVRCP_HANDLE_CONTROL:
+ case BT_AVRCP_SET_TRACK_INFO:
+ case BT_AVRCP_SET_PROPERTY:
+ case BT_AVRCP_SET_PROPERTIES:
+ case BT_AVRCP_CONTROL_SET_PROPERTY:
+
+ case BT_HF_CONNECT:
+ case BT_HF_DISCONNECT:
+
+ case BT_HID_CONNECT:
+ case BT_HID_DISCONNECT:
+
+ case BT_HID_DEVICE_ACTIVATE:
+ case BT_HID_DEVICE_DEACTIVATE:
+ case BT_HID_DEVICE_CONNECT:
+ case BT_HID_DEVICE_DISCONNECT:
+ case BT_HID_DEVICE_SEND_MOUSE_EVENT:
+ case BT_HID_DEVICE_SEND_KEY_EVENT:
+ case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
+ case BT_HID_DEVICE_SEND_CUSTOM_EVENT:
+
+ case BT_CONNECT_LE:
+ case BT_DISCONNECT_LE:
+
+ case BT_SET_ADVERTISING_DATA:
+ case BT_SET_SCAN_RESPONSE_DATA:
+
+ case BT_HDP_CONNECT:
+ case BT_HDP_DISCONNECT:
+ case BT_HDP_SEND_DATA:
+ case BT_HDP_REGISTER_SINK_APP:
+ case BT_HDP_UNREGISTER_SINK_APP:
+
+ case BT_DPM_SET_ALLOW_BT_MODE:
+ case BT_DPM_GET_ALLOW_BT_MODE:
+ case BT_DPM_SET_DEVICE_RESTRITION:
+ case BT_DPM_GET_DEVICE_RESTRITION:
+ case BT_DPM_SET_UUID_RESTRITION:
+ case BT_DPM_GET_UUID_RESTRITION:
+ case BT_DPM_ADD_DEVICES_BLACKLIST:
+ case BT_DPM_ADD_DEVICES_WHITELIST:
+ case BT_DPM_ADD_UUIDS_BLACKLIST:
+ case BT_DPM_ADD_UUIDS_WHITELIST:
+ case BT_DPM_CLEAR_DEVICES_BLACKLIST:
+ case BT_DPM_CLEAR_DEVICES_WHITELIST:
+ case BT_DPM_CLEAR_UUIDS_BLACKLIST:
+ case BT_DPM_CLEAR_UUIDS_WHITELIST:
+ case BT_DPM_REMOVE_DEVICE_BLACKLIST:
+ case BT_DPM_REMOVE_DEVICE_WHITELIST:
+ case BT_DPM_REMOVE_UUID_BLACKLIST:
+ case BT_DPM_REMOVE_UUID_WHITELIST:
+ case BT_DPM_GET_DEVICES_BLACKLIST:
+ case BT_DPM_GET_DEVICES_WHITELIST:
+ case BT_DPM_GET_UUIDS_BLACKLIST:
+ case BT_DPM_GET_UUIDS_WHITELIST:
+ case BT_DPM_SET_ALLOW_OUTGOING_CALL:
+ case BT_DPM_GET_ALLOW_OUTGOING_CALL:
+ case BT_DPM_SET_PAIRING_STATE:
+ case BT_DPM_GET_PAIRING_STATE:
+ case BT_DPM_SET_PROFILE_STATE:
+ case BT_DPM_GET_PROFILE_STATE:
+ case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
+ case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
+ case BT_DPM_SET_DISCOVERABLE_STATE:
+ case BT_DPM_GET_DISCOVERABLE_STATE:
+ case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
+ case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
+ case BT_DPM_SET_DATA_TRANSFER_STATE:
+ case BT_DPM_GET_DATA_TRANSFER_STATE:
+
+ case BT_NETWORK_ACTIVATE:
+ case BT_NETWORK_DEACTIVATE:
+ case BT_NETWORK_CONNECT:
+ case BT_NETWORK_DISCONNECT:
+ case BT_NETWORK_SERVER_DISCONNECT:
+
+ case BT_GATT_GET_PRIMARY_SERVICES:
+ case BT_GATT_DISCOVER_CHARACTERISTICS:
+ case BT_GATT_SET_PROPERTY_REQUEST:
+ case BT_GATT_READ_CHARACTERISTIC:
+ case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
+ case BT_GATT_REGISTER_APPLICATION:
+ case BT_GATT_REGISTER_SERVICE:
+ case BT_GATT_SEND_RESPONSE:
+ case BT_PBAP_CONNECT:
+ case BT_PBAP_DISCONNECT:
+ case BT_PBAP_GET_PHONEBOOK_SIZE:
+ case BT_PBAP_GET_PHONEBOOK:
+ case BT_PBAP_GET_LIST:
+ case BT_PBAP_PULL_VCARD:
+ case BT_PBAP_PHONEBOOK_SEARCH:
+
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ BT_PRIVILEGE_PUBLIC);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
+ result = FALSE;
+ }
+
+ /* Need to check mediastorage privilege */
+ if (function_name == BT_PBAP_GET_PHONEBOOK ||
+ function_name == BT_PBAP_PULL_VCARD) {
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ MEDIASTORAGE_PRIVILEGE);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
+ result = FALSE;
+ }
+ }
+ break;
+
+ case BT_ENABLE_ADAPTER:
+ case BT_DISABLE_ADAPTER:
+ case BT_RESET_ADAPTER:
+ case BT_RECOVER_ADAPTER:
+ case BT_ENABLE_ADAPTER_LE:
+ case BT_DISABLE_ADAPTER_LE:
+ case BT_SET_CONNECTABLE:
+ case BT_SET_DISCOVERABLE_MODE:
+ case BT_ADD_WHITE_LIST:
+ case BT_REMOVE_WHITE_LIST:
+ case BT_CLEAR_WHITE_LIST:
+ case BT_SET_MANUFACTURER_DATA:
+ case BT_SET_PROFILE_RESTRICTED:
+
+ case BT_CANCEL_SEARCH_SERVICE:
+ case BT_ENABLE_RSSI:
+
+ case BT_RFCOMM_ACCEPT_CONNECTION:
+ case BT_RFCOMM_REJECT_CONNECTION:
+ case BT_RFCOMM_LISTEN:
+
+ case BT_AVRCP_CONTROL_GET_PROPERTY:
+ case BT_AVRCP_GET_TRACK_INFO:
+
+ case BT_SET_CONTENT_PROTECT:
+ case BT_BOND_DEVICE_BY_TYPE:
+ case BT_SET_LE_PRIVACY:
+ case BT_LE_CONN_UPDATE:
+ case BT_LE_READ_MAXIMUM_DATA_LENGTH:
+ case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
+ case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
+ case BT_LE_SET_DATA_LENGTH:
+
+ case BT_GET_ATT_MTU:
+
+ case BT_LE_IPSP_INIT:
+ case BT_LE_IPSP_DEINIT:
+ case BT_LE_IPSP_CONNECT:
+ case BT_LE_IPSP_DISCONNECT:
+ case BT_PXP_SET_PROPERTY:
+ case BT_PXP_GET_PROPERTY:
+ case BT_PXP_GET_SUPPORTED_SERIVCES:
+ case BT_PXP_REGISTER_REPORTER:
+ case BT_PXP_UNREGISTER_REPORTER:
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ BT_PRIVILEGE_PLATFORM);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
+ result = FALSE;
+ }
+ break;
+
+ case BT_CHECK_ADAPTER:
+ case BT_GET_RSSI:
+
+ case BT_GET_LOCAL_NAME:
+ case BT_GET_LOCAL_ADDRESS:
+ case BT_GET_LOCAL_VERSION:
+ case BT_IS_SERVICE_USED:
+ case BT_GET_DISCOVERABLE_MODE:
+ case BT_GET_DISCOVERABLE_TIME:
+ case BT_IS_DISCOVERYING:
+ case BT_IS_LE_DISCOVERYING:
+ case BT_IS_CONNECTABLE:
+ case BT_GET_BONDED_DEVICES:
+ case BT_GET_BONDED_DEVICE:
+ case BT_GET_IS_ALIAS_SET:
+ case BT_IS_DEVICE_CONNECTED:
+ case BT_GET_SPEAKER_GAIN:
+ case BT_SET_SPEAKER_GAIN:
+ case BT_OOB_READ_LOCAL_DATA:
+ case BT_RFCOMM_CLIENT_IS_CONNECTED:
+ case BT_RFCOMM_IS_UUID_AVAILABLE:
+ case BT_GET_ADVERTISING_DATA:
+ case BT_GET_SCAN_RESPONSE_DATA:
+ case BT_IS_ADVERTISING:
+ case BT_GET_PROFILE_RESTRICTED:
+
+ case BT_OBEX_SERVER_ALLOCATE:
+ case BT_OBEX_SERVER_DEALLOCATE:
+ /* Non-privilege control */
+ break;
+ default:
+ BT_ERR("Unknown function!");
+ result = FALSE;
+ break;
+ }
+
+ if (client_creds)
+ free(client_creds);
+
+ if (user_creds)
+ free(user_creds);
+
+ return result;
}
GDBusNodeInfo *__bt_service_create_method_node_info
int _bt_service_cynara_init(void)
{
- int result;
- char err_msg[256] = {0, };
+ int result;
+ char err_msg[256] = {0, };
- retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
+ retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
- result = cynara_initialize(&p_cynara, conf);
+ result = cynara_initialize(&p_cynara, conf);
- if (result != CYNARA_API_SUCCESS) {
- cynara_strerror(result, err_msg, sizeof(err_msg));
- BT_ERR("Fail to initialize cynara: [%s]", err_msg);
- return BLUETOOTH_ERROR_INTERNAL;
- }
+ if (result != CYNARA_API_SUCCESS) {
+ cynara_strerror(result, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to initialize cynara: [%s]", err_msg);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- return BLUETOOTH_ERROR_NONE;
+ return BLUETOOTH_ERROR_NONE;
}
void _bt_service_cynara_deinit(void)
{
- int result;
- char err_msg[256] = {0, };
+ int result;
+ char err_msg[256] = {0, };
- ret_if(p_cynara == NULL);
+ ret_if(p_cynara == NULL);
- result = cynara_finish(p_cynara);
+ result = cynara_finish(p_cynara);
- if (result != CYNARA_API_SUCCESS) {
- cynara_strerror(result, err_msg, sizeof(err_msg));
- BT_ERR("Fail to finish cynara: [%s]", err_msg);
- return;
- }
+ if (result != CYNARA_API_SUCCESS) {
+ cynara_strerror(result, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to finish cynara: [%s]", err_msg);
+ return;
+ }
- p_cynara = NULL;
- conf = NULL;
+ p_cynara = NULL;
+ conf = NULL;
}
#include <dlog.h>
#include <string.h>
#include <vconf.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
#include <aul.h>
#include "bt-internal-types.h"
#define BT_ADV_FILTER_POLICY_DEFAULT 0x00
#define BT_ADV_TYPE_DEFAULT 0x00
#define BT_ADV_FILTER_POLICY_ALLOW_SCAN_CONN_WL_ONLY 0x03
+#define BT_ADV_MULTI_MAX 16
typedef struct {
int adv_inst_max;
char *sender;
int adv_handle;
gboolean is_advertising;
+ guint hold_timer_id;
} bt_adapter_le_adv_slot_t;
typedef struct {
return FALSE;
if (g_strcmp0(item, "adv_inst_max") == 0) {
- if (atoi(value) != le_feature_info.adv_inst_max) {
+ int slot_num;
+
+ slot_num = atoi(value);
+ retv_if(slot_num < 0, FALSE);
+ retv_if(slot_num > BT_ADV_MULTI_MAX, FALSE);
+
+ if (slot_num != le_feature_info.adv_inst_max) {
__bt_free_le_adv_slot();
- le_feature_info.adv_inst_max = atoi(value);
+ le_feature_info.adv_inst_max = slot_num;
+ BT_INFO("Advertising instance max : %d", le_feature_info.adv_inst_max);
le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
}
} else if (g_strcmp0(item, "rpa_offloading") == 0) {
le_feature_info.rpa_offloading = atoi(value);
+ BT_INFO("RPA offloading : %d", le_feature_info.rpa_offloading);
} else if (g_strcmp0(item, "max_filter") == 0) {
le_feature_info.max_filter = atoi(value);
+ BT_INFO("BLE Scan max filter : %d", le_feature_info.max_filter);
} else {
BT_DBG("No registered item");
return FALSE;
static gboolean __bt_is_factory_test_mode(void)
{
int mode = 0;
-#ifdef ENABLE_TIZEN_2_4
+
if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
BT_ERR("Get the DUT Mode fail");
return TRUE;
}
-#endif
+
if (mode != FALSE) {
BT_INFO("DUT Test Mode !!");
return TRUE;
{
int i;
- if (le_adv_slot == NULL)
+ if (le_adv_slot == NULL) {
+ BT_ERR("le_adv_slot is NULL");
return -1;
+ }
+
+ BT_DBG("adv_inst_max : %d", le_feature_info.adv_inst_max);
for (i = 0; i < le_feature_info.adv_inst_max; i++) {
if (le_adv_slot[i].sender == NULL)
return -1;
}
-void _bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id)
+static void __bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id)
{
if (le_adv_slot[slot_id].sender == NULL) {
le_adv_slot[slot_id].sender = strdup(sender);
if (le_adv_slot[slot_id].sender != NULL && le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
return BLUETOOTH_ERROR_NOT_IN_OPERATION;
+ if (le_adv_slot[slot_id].hold_timer_id > 0) {
+ g_source_remove(le_adv_slot[slot_id].hold_timer_id);
+ le_adv_slot[slot_id].hold_timer_id = 0;
+ }
+
proxy = _bt_get_adapter_proxy();
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
}
if (enable == TRUE)
- _bt_register_adv_slot_owner(sender, adv_handle, slot_id);
+ __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
le_adv_slot[slot_id].is_advertising = enable;
- BT_INFO("Set advertising [%d]", enable);
+ BT_INFO_C("### Set advertising [%d]", enable);
if (ret)
g_variant_unref(ret);
if (le_adv_slot[slot_id].sender != NULL && le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
return BLUETOOTH_ERROR_NOT_IN_OPERATION;
+ if (le_adv_slot[slot_id].hold_timer_id > 0) {
+ g_source_remove(le_adv_slot[slot_id].hold_timer_id);
+ le_adv_slot[slot_id].hold_timer_id = 0;
+ }
+
proxy = _bt_get_adapter_proxy();
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
max = params->interval_max / BT_ADV_INTERVAL_SPLIT;
ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingParameters",
- g_variant_new("(uuuui)", min, max,
+ g_variant_new("(uuuui)", min, max,
params->filter_policy, params->type,
slot_id), G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
}
if (enable == TRUE)
- _bt_register_adv_slot_owner(sender, adv_handle, slot_id);
+ __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
else
_bt_unregister_adv_slot_owner(slot_id);
le_adv_slot[slot_id].is_advertising = enable;
- BT_INFO_C("Set advertising [%d]", enable);
+ BT_INFO_C("### Set advertising [%d]", enable);
if (ret)
g_variant_unref(ret);
return BLUETOOTH_ERROR_NONE;
}
+static gboolean __bt_hold_current_advertising_timeout_cb(gpointer user_data)
+{
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ GVariant *ret;
+
+ BT_INFO("Restart advertising stopped by bt-service");
+
+ le_adv_slot[0].hold_timer_id = 0;
+
+ proxy = _bt_get_adapter_proxy();
+ retv_if(proxy == NULL, FALSE);
+
+ ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
+ g_variant_new("(bi)", TRUE, 0),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (error) {
+ BT_ERR("SetAdvertising Fail: %s", error->message);
+ g_clear_error(&error);
+ return FALSE;
+ }
+
+ if (ret)
+ g_variant_unref(ret);
+
+ return FALSE;
+}
+
+int _bt_hold_current_advertising(void)
+{
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ GVariant *ret;
+
+ if (le_adv_slot[0].sender && le_adv_slot[0].is_advertising == TRUE) {
+ BT_INFO("Stop current advertising by bt-service");
+
+ proxy = _bt_get_adapter_proxy();
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
+ g_variant_new("(bi)", FALSE, 0),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (error) {
+ BT_ERR("SetAdvertising Fail: %s", error->message);
+ g_clear_error(&error);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ if (ret)
+ g_variant_unref(ret);
+
+ le_adv_slot[0].hold_timer_id = g_timeout_add(2000,
+ __bt_hold_current_advertising_timeout_cb, NULL);
+ } else {
+ BT_ERR("It's NOT advertising");
+ return BLUETOOTH_ERROR_NOT_IN_OPERATION;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
static int __bt_get_ad_data_by_type(char *in_data, int in_len,
char in_type, char **data, int *data_len)
{
}
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < length; i++) {
+ for (i = 0; i < length; i++)
g_variant_builder_add(builder, "y", adv->data[i]);
- }
temp = g_variant_new("ay", builder);
g_variant_builder_unref(builder);
return BLUETOOTH_ERROR_INTERNAL;
}
- _bt_register_adv_slot_owner(sender, adv_handle, slot_id);
+ __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
__bt_get_ad_data_by_type((char *)adv_data.data, adv_data_len, 0xff,
&old_mdata, &old_len);
if (old_len != new_len ||
(old_mdata && new_mdata &&
memcmp(old_mdata, new_mdata, new_len))) {
- ad_data = g_variant_new_from_data((const GVariantType *)"ay",
- new_mdata, new_len, TRUE, NULL, NULL);
+ ad_data = g_variant_new_from_data((const GVariantType *)"ay",
+ new_mdata, new_len, TRUE, NULL, NULL);
param = g_variant_new("(@ay)", ad_data);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
return BLUETOOTH_ERROR_NO_RESOURCES;
}
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < length; i++) {
+ for (i = 0; i < length; i++)
g_variant_builder_add(builder, "y", response->data[i]);
- }
temp = g_variant_new("ay", builder);
g_variant_builder_unref(builder);
return BLUETOOTH_ERROR_INTERNAL;
}
- _bt_register_adv_slot_owner(sender, adv_handle, slot_id);
+ __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
/* Compare with previous scan resp data */
__bt_get_ad_data_by_type((char *)resp_data.data, resp_data_len, 0xff,
(old_mdata && new_mdata &&
memcmp(old_mdata, new_mdata, new_len))) {
scan_data = g_variant_new_from_data((const GVariantType *)"ay",
- new_mdata, new_len, TRUE, NULL, NULL);
+ new_mdata, new_len, TRUE, NULL, NULL);
param = g_variant_new("(@ay)", scan_data);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
scanner = l->data;
for (fl = scanner->filter_list; fl != NULL; fl = g_slist_next(fl)) {
filter_data = fl->data;
- if (filter_data->slot_id < le_feature_info.max_filter) {
+ if (filter_data->slot_id < le_feature_info.max_filter)
slot_check_list[filter_data->slot_id] = TRUE;
- }
}
}
return -1;
}
+gboolean _bt_is_scan_filter_supported(void)
+{
+ if (le_feature_info.max_filter > 0)
+ return TRUE;
+
+ return FALSE;
+}
+
int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id)
{
GDBusProxy *proxy;
g_array_append_vals(arr_uuid_mask, filter->service_uuid_mask.data.data, filter->service_uuid_mask.data_len * sizeof(guint8));
arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
+ arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
+ arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
NULL, 0, TRUE, NULL, NULL);
arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
g_array_append_vals(arr_uuid_mask, filter->service_solicitation_uuid_mask.data.data, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8));
arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
+ arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
+ arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
NULL, 0, TRUE, NULL, NULL);
arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
NULL, 0, TRUE, NULL, NULL);
arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_data->data, arr_data->len, TRUE, NULL, NULL);
+ arr_data->data, arr_data->len, TRUE, NULL, NULL);
arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
+ arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
0, // client_if
arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
NULL, 0, TRUE, NULL, NULL);
arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_data->data, arr_data->len, TRUE, NULL, NULL);
+ arr_data->data, arr_data->len, TRUE, NULL, NULL);
arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
- arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
+ arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
0, // client_if
__bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
ad_type, &data, &data_len);
if (data != NULL) {
- _bt_swap_byte_ordering(data, data_len);
for (i = 0; i < data_len; i += uuid_len) {
if (uuid_len > (data_len - i))
break;
adv_data_len,
BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
&data, &data_len);
+
if (data != NULL) {
- if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
- data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
- if (_bt_byte_arr_cmp_with_mask(data,
- (char*)filter_data->manufacturer_data.data.data,
- (char*)filter_data->manufacturer_data_mask.data.data,
- data_len) == 0) {
- is_matched = TRUE;
+ int manufacturer_id;
+ manufacturer_id = (data[1] << 8) + data[0];
+
+ if (filter_data->manufacturer_id == manufacturer_id) {
+ if (filter_data->manufacturer_data.data_len == 0) {
+ is_matched = TRUE;
+ } else {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ if (_bt_byte_arr_cmp_with_mask(data + 2,
+ (char*)filter_data->manufacturer_data.data.data,
+ (char*)filter_data->manufacturer_data_mask.data.data,
+ data_len - 2) == 0) {
+ is_matched = TRUE;
+ }
+ }
}
g_free(data);
data = NULL;
scan_data_len,
BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
&data, &data_len);
+
if (data != NULL) {
- if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
- data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
- if (_bt_byte_arr_cmp_with_mask(data,
- (char*)filter_data->manufacturer_data.data.data,
- (char*)filter_data->manufacturer_data_mask.data.data,
- data_len) == 0) {
- is_matched = TRUE;
+ int manufacturer_id;
+ manufacturer_id = (data[1] << 8) + data[0];
+
+ if (filter_data->manufacturer_id == manufacturer_id) {
+ if (filter_data->manufacturer_data.data_len == 0) {
+ is_matched = TRUE;
+ } else {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ if (_bt_byte_arr_cmp_with_mask(data + 2,
+ (char*)filter_data->manufacturer_data.data.data,
+ (char*)filter_data->manufacturer_data_mask.data.data,
+ data_len - 2) == 0) {
+ is_matched = TRUE;
+ }
+ }
}
g_free(data);
data = NULL;
}
}
+void _bt_send_ibeacon_scan_result_event(const bt_remote_ibeacon_dev_info_t *ibeacon_dev_info)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ GSList *l;
+ GVariant *param;
+ bt_adapter_le_scanner_t *scanner = NULL;
+
+ ret_if(ibeacon_dev_info == NULL);
+ BT_DBG("_bt_send_ibeacon_scan_result_event");
+
+ for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
+ scanner = l->data;
+ if (scanner->is_scanning == FALSE)
+ continue;
+
+ param = g_variant_new("(isnnnsnnn)",
+ result,
+ ibeacon_dev_info->address,
+ ibeacon_dev_info->addr_type,
+ ibeacon_dev_info->company_id,
+ ibeacon_dev_info->ibeacon_type,
+ ibeacon_dev_info->uuid,
+ ibeacon_dev_info->major_id,
+ ibeacon_dev_info->minor_id,
+ ibeacon_dev_info->measured_power);
+
+ _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_REMOTE_IBEACON_DEVICE_FOUND, param);
+ }
+}
+
int _bt_add_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
{
GDBusProxy *proxy;
return BLUETOOTH_ERROR_INTERNAL;
}
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL) {
BT_ERR("conn == NULL");
g_free(device_path);
#include <dlog.h>
#include <string.h>
#include <vconf.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
#include <aul.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus.h>
#include "bt-service-util.h"
#include "bt-service-network.h"
#include "bt-service-obex-server.h"
+#include "bt-service-opp-client.h"
#include "bt-service-agent.h"
#include "bt-service-main.h"
#include "bt-service-avrcp.h"
guint event_id;
int timeout;
time_t start_time;
- gboolean alarm_init;
int alarm_id;
} bt_adapter_timer_t;
bt_adapter_timer_t visible_timer = {0, };
+typedef struct {
+ alarm_id_t alarm_id;
+ bt_set_alarm_cb callback;
+ void *user_data;
+} bt_service_alarm_t;
+
+typedef struct {
+ gboolean is_alarm_initialized;
+ GList *g_alarm_list;
+} bt_service_alarm_mgr_t;
+
+static bt_service_alarm_mgr_t alarm_mgr = {0, };
+
static gboolean is_discovering;
static gboolean cancel_by_user;
static bt_status_t adapter_status = BT_DEACTIVATED;
static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
+static gboolean is_le_intended = FALSE;
static void *adapter_agent = NULL;
static GDBusProxy *core_proxy = NULL;
static guint timer_id = 0;
static guint le_timer_id = 0;
+static gboolean is_recovery_mode;
static uint status_reg_id;
#define BT_DISABLE_TIME 500 /* 500 ms */
+static int alarm_cb(alarm_id_t alarm_id, void* user_param);
+static void alarm_data_free(void *data);
+
GDBusProxy *_bt_init_core_proxy(void)
{
GDBusProxy *proxy;
GDBusConnection *conn;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (!conn)
return NULL;
static GDBusProxy *__bt_get_core_proxy(void)
{
- return (core_proxy) ? core_proxy : _bt_init_core_proxy();
+ return (core_proxy) ? core_proxy : _bt_init_core_proxy();
}
static gboolean __bt_is_factory_test_mode(void)
{
int mode = 0;
-#ifdef ENABLE_TIZEN_2_4
if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
BT_ERR("Get the DUT Mode fail");
return TRUE;
}
-#endif
if (mode != FALSE) {
BT_INFO("DUT Test Mode !!");
visible_timer.event_id = 0;
visible_timer.timeout = 0;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
BT_ERR("Set vconf failed\n");
#endif
static int __bt_visibility_alarm_cb(alarm_id_t alarm_id, void* user_param)
{
- BT_DBG("__bt_visibility_alarm_cb - alram id = [%d] \n", alarm_id);
int result = BLUETOOTH_ERROR_NONE;
int timeout = 0;
visible_timer.event_id = 0;
visible_timer.timeout = 0;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
BT_ERR("Set vconf failed\n");
#endif
return 0;
}
-static void __bt_visibility_alarm_create()
-{
- alarm_id_t alarm_id;
- int result;
-
- result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, visible_timer.timeout,
- 0, NULL, &alarm_id);
- if (result < 0) {
- BT_ERR("Failed to create alarm error = %d\n", result);
- } else {
- BT_DBG("Alarm created = %d\n", alarm_id);
- visible_timer.alarm_id = alarm_id;
- }
-}
-
static void __bt_visibility_alarm_remove()
{
if (visible_timer.event_id > 0) {
}
if (visible_timer.alarm_id > 0) {
- alarmmgr_remove_alarm(visible_timer.alarm_id);
+ _bt_service_remove_alarm(visible_timer.alarm_id);
visible_timer.alarm_id = 0;
}
}
int __bt_set_visible_time(int timeout)
{
int result;
+ alarm_id_t alarm_id;
__bt_visibility_alarm_remove();
visible_timer.timeout = timeout;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#ifdef TIZEN_DPM_ENABLE
if (_bt_dpm_get_bluetooth_limited_discoverable_state() != DPM_RESTRICTED) {
#endif
#endif
#endif
+
if (timeout <= 0)
return BLUETOOTH_ERROR_NONE;
- if (!visible_timer.alarm_init) {
- /* Set Alarm timer to switch off BT */
- result = alarmmgr_init("bt-service");
- if (result != 0)
- return BLUETOOTH_ERROR_INTERNAL;
-
- visible_timer.alarm_init = TRUE;
- }
-
- result = alarmmgr_set_cb(__bt_visibility_alarm_cb, NULL);
- if (result != 0)
+ result = _bt_service_set_alarm(visible_timer.timeout,
+ __bt_visibility_alarm_cb, NULL, &alarm_id);
+ if (result != BLUETOOTH_ERROR_NONE)
return BLUETOOTH_ERROR_INTERNAL;
-
+ visible_timer.alarm_id = alarm_id;
/* Take start time */
time(&(visible_timer.start_time));
visible_timer.event_id = g_timeout_add_seconds(1,
__bt_timeout_handler, NULL);
- __bt_visibility_alarm_create();
-
return BLUETOOTH_ERROR_NONE;
}
BT_CHECK_PARAMETER(device_path, return);
BT_CHECK_PARAMETER(dev_info, return);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
} else if (!g_strcmp0(key, "ManufacturerData")) {
manufacturer_data = g_byte_array_new();
g_variant_get(value, "ay", &char_value_iter);
-
while (g_variant_iter_loop(char_value_iter, "y", &char_value))
g_byte_array_append(manufacturer_data, &char_value, 1);
manufacturer_data->len);
}
}
+ g_byte_array_free(manufacturer_data, TRUE);
}
}
g_variant_iter_free(property_iter);
g_variant_unref(result);
if ((paired == FALSE) && (trust == FALSE)) {
+ g_free(address);
+ g_free(name);
return BLUETOOTH_ERROR_NOT_PAIRED;
}
return adapter_le_status;
}
+
+void _bt_set_le_intended_status(gboolean value)
+{
+ is_le_intended = value;
+}
+
static void __bt_phone_name_changed_cb(keynode_t *node, void *data)
{
char *phone_name = NULL;
phone_name = vconf_keynode_get_str(node);
if (phone_name && strlen(phone_name) != 0) {
- if (!g_utf8_validate(phone_name, -1,
+ if (!g_utf8_validate(phone_name, -1,
(const char **)&ptr))
- *ptr = '\0';
+ *ptr = '\0';
_bt_set_local_name(phone_name);
}
}
}
-#ifdef TIZEN_MOBILE
-static void __bt_set_visible_mode(void)
-{
- int timeout = 0;
-
- if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
- BT_ERR("Fail to get the timeout value");
-
-#ifdef TIZEN_DPM_ENABLE
- if (timeout == -1 ||
- _bt_dpm_get_bluetooth_limited_discoverable_state() == DPM_RESTRICTED) {
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
- timeout) != BLUETOOTH_ERROR_NONE) {
- if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
- BT_ERR("Set vconf failed");
- }
- } else {
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
- timeout) != BLUETOOTH_ERROR_NONE) {
- BT_ERR("Set connectable mode failed");
- }
- }
-#else
- if (timeout == -1) {
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
- timeout) != BLUETOOTH_ERROR_NONE) {
- if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
- BT_ERR("Set vconf failed");
- }
- } else {
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,
- timeout) != BLUETOOTH_ERROR_NONE) {
- BT_ERR("Set connectable mode failed");
- }
- }
-#endif
-}
-#endif
-
static void __bt_set_local_name(void)
{
+ bluetooth_device_name_t local_name;
char *phone_name = NULL;
char *ptr = NULL;
+ char *temp = NULL;
- phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
+ if (_bt_get_local_name(&local_name) != BLUETOOTH_ERROR_NONE ||
+ (temp = strstr(local_name.name, "BlueZ")) != NULL) {
+ phone_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
- if (!phone_name)
- return;
+ if (!phone_name)
+ return;
- if (strlen(phone_name) != 0) {
- if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
- *ptr = '\0';
+ if (strlen(phone_name) != 0) {
+ if (!g_utf8_validate(phone_name, -1, (const char **)&ptr))
+ *ptr = '\0';
- _bt_set_local_name(phone_name);
+ _bt_set_local_name(phone_name);
+ }
+ free(phone_name);
}
- free(phone_name);
}
static int __bt_set_enabled(void)
{
- BT_DBG("+");
int adapter_status = BT_ADAPTER_DISABLED;
int result = BLUETOOTH_ERROR_NONE;
+ if (timer_id > 0) {
+ BT_DBG("g_source is removed");
+ g_source_remove(timer_id);
+ timer_id = 0;
+ }
+
_bt_check_adapter(&adapter_status);
if (adapter_status == BT_ADAPTER_DISABLED) {
return BLUETOOTH_ERROR_INTERNAL;
}
-#ifdef TIZEN_MOBILE
- __bt_set_visible_mode();
+#ifdef TIZEN_PROFILE_MOBILE || defined(TIZEN_PROFILE_IVI)
+ /* BT setting UI will control Mobile's visible mode. So in the FRWK...set the visible mode as off: */
+ if (_bt_set_discoverable_mode(
+ BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0) != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Set connectable mode failed");
#else
#ifdef TIZEN_TV
if (_bt_set_discoverable_mode(
BT_ERR("Fail to set discoverable mode");
#endif
#endif
- __bt_set_local_name();
/* Update Bluetooth Status to notify other modules */
if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_ON) != 0)
if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
BT_ERR("Set vconf failed\n");
-#if 0
+
if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
EVT_VAL_BT_ON) != ES_R_OK)
BT_ERR("Fail to set value");
-#endif
/* Send enabled event to API */
_bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
g_variant_new("(i)", result));
- BT_DBG("-");
+
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+ _bt_audio_start_auto_connect(FALSE);
+#endif
+
+ __bt_set_local_name();
+ _bt_set_discovery_status(FALSE);
return BLUETOOTH_ERROR_NONE;
}
if (vconf_set_int(VCONFKEY_BT_DEVICE, VCONFKEY_BT_DEVICE_NONE) != 0)
BT_ERR("Set vconf failed\n");
+ _bt_cancel_queued_transfers();
_bt_adapter_set_status(BT_DEACTIVATED);
+ _bt_set_discovery_status(FALSE);
+#ifndef USB_BLUETOOTH
if (_bt_adapter_get_le_status() != BT_LE_DEACTIVATED) {
+#endif
/* Send disabled event */
_bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
g_variant_new("(i)", result));
+#ifndef USB_BLUETOOTH
}
+#endif
BT_INFO("Adapter disabled");
}
int result = BLUETOOTH_ERROR_NONE;
bt_status_t status;
- __bt_set_local_name();
-
/* Update Bluetooth Status to notify other modules */
if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_ON) != 0)
BT_ERR("Set vconf failed\n");
_bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_ENABLED,
g_variant_new("(i)", result));
+ __bt_set_local_name();
+
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
/* Send disabled event */
_bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_LE_DISABLED,
- g_variant_new_int32(result));
+ g_variant_new("(i)", result));
}
void *_bt_get_adapter_agent(void)
return BLUETOOTH_ERROR_NONE;
}
-#if defined(TIZEN_BT_FLIGHTMODE_ENABLED) || (!defined(TIZEN_WEARABLE) && defined(ENABLE_TIZEN_2_4))
+#if defined(TIZEN_FEATURE_FLIGHTMODE_ENABLED) || (!defined(TIZEN_PROFILE_WEARABLE))
static void __bt_service_flight_ps_mode_cb(keynode_t *node, void *data)
{
gboolean flight_mode = FALSE;
{
BT_DBG("+");
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
BT_ERR("Unable to register key handler");
BT_DBG("Telephony is disabled");
#endif
-#ifndef TIZEN_WEARABLE
-#ifdef ENABLE_TIZEN_2_4
+#ifndef TIZEN_PROFILE_WEARABLE
if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb, NULL) < 0)
BT_ERR("Unable to register key handler");
#endif
-#endif
}
void _bt_service_unregister_vconf_handler(void)
{
BT_DBG("+");
-#ifdef TIZEN_BT_FLIGHTMODE_ENABLED
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
vconf_ignore_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb);
#endif
-#ifndef TIZEN_WEARABLE
-#ifdef ENABLE_TIZEN_2_4
+#ifndef TIZEN_PROFILE_WEARABLE
vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
(vconf_callback_fn)__bt_service_flight_ps_mode_cb);
#endif
-#endif
}
static void __bt_state_event_handler(const char *event_name, bundle *data, void *user_data)
{
-#ifdef ENABLE_TIZEN_2_4
const char *bt_status = NULL;
const char *bt_le_status = NULL;
BT_DBG("bt state set event(%s) received", event_name);
+
bt_status = bundle_get_val(data, EVT_KEY_BT_STATE);
BT_DBG("bt_state: (%s)", bt_status);
bt_le_status = bundle_get_val(data, EVT_KEY_BT_LE_STATE);
BT_DBG("bt_state: (%s)", bt_le_status);
-#endif
}
void _bt_handle_adapter_added(void)
bt_status_t status;
bt_le_status_t le_status;
int ret;
-
+/*
if (timer_id > 0) {
BT_DBG("g_source is removed");
g_source_remove(timer_id);
timer_id = 0;
}
+*/
status = _bt_adapter_get_status();
le_status = _bt_adapter_get_le_status();
BT_DBG("status : %d", status);
BT_DBG("le_status : %d", le_status);
+#ifndef USB_BLUETOOTH
adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
if (!adapter_agent) {
BT_ERR("Fail to register agent");
return;
}
+#else
+ if (adapter_agent == NULL) {
+ adapter_agent = _bt_create_agent(BT_ADAPTER_AGENT_PATH, TRUE);
+ if (!adapter_agent) {
+ BT_ERR("Fail to register agent");
+ return;
+ }
+ }
+#endif
if (_bt_register_media_player() != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to register media player");
if (_bt_register_obex_server() != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to init obex server");
-#ifdef TIZEN_BT_PAN_NAP_ENABLE
+#ifdef TIZEN_BT_PAN_NAP_ENABLED
if (_bt_network_activate() != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to activate network");
#endif
__bt_set_enabled();
_bt_adapter_set_status(BT_ACTIVATED);
}
-#ifdef ENABLE_TIZEN_2_4
- journal_bt_on();
-#endif
-
- _bt_service_register_vconf_handler();
/* eventsystem */
if (eventsystem_register_event(SYS_EVENT_BT_STATE, &status_reg_id,
int ret;
_bt_adapter_set_status(BT_DEACTIVATED);
-#ifdef ENABLE_TIZEN_2_4
- journal_bt_off();
-#endif
__bt_visibility_alarm_remove();
- if (visible_timer.alarm_init) {
+ if (alarm_mgr.is_alarm_initialized == TRUE) {
alarmmgr_fini();
- visible_timer.alarm_init = FALSE;
+ alarm_mgr.is_alarm_initialized = FALSE;
+ g_list_free_full(alarm_mgr.g_alarm_list, alarm_data_free);
+ alarm_mgr.g_alarm_list = NULL;
}
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+ _bt_audio_stop_auto_connect();
+#endif
+
ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
(vconf_callback_fn)__bt_phone_name_changed_cb);
- if (0 != ret) {
+ if (0 != ret)
ERR("vconf_ignore_key_changed failed\n");
- }
+#ifndef USB_BLUETOOTH
_bt_destroy_agent(adapter_agent);
adapter_agent = NULL;
- _bt_reliable_terminate_service(NULL);
+ if (is_recovery_mode == TRUE) {
+ /* Send disabled event */
+ _bt_set_disabled(BLUETOOTH_ERROR_NONE);
- if (eventsystem_unregister_event(status_reg_id) != ES_R_OK) {
- BT_ERR("Fail to unregister system event");
+ /* Will recover BT by bt-core, so set the mode as activating */
+ _bt_adapter_set_status(BT_ACTIVATING);
+ is_recovery_mode = FALSE;
+ } else {
+ _bt_reliable_terminate_service(NULL);
}
+#else
+ _bt_set_disabled(BLUETOOTH_ERROR_NONE);
+#endif
+ if (eventsystem_unregister_event(status_reg_id) != ES_R_OK)
+ BT_ERR("Fail to unregister system event");
}
static gboolean __bt_enable_timeout_cb(gpointer user_data)
g_variant_unref(result);
_bt_set_disabled(BLUETOOTH_ERROR_TIMEOUT);
+#ifndef USB_BLUETOOTH
_bt_terminate_service(NULL);
+#endif
return FALSE;
}
}
#endif
+int _bt_enable_adapter_check_status(void)
+{
+ bt_status_t status = _bt_adapter_get_status();
+ bt_le_status_t le_status = _bt_adapter_get_le_status();
+
+ BT_DBG("");
+
+ if (status == BT_ACTIVATING) {
+ BT_ERR("Enabling in progress");
+ return BLUETOOTH_ERROR_IN_PROGRESS;
+ }
+
+ if (status == BT_ACTIVATED) {
+ BT_ERR("Already enabled");
+ return BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
+ }
+
+ if (status == BT_DEACTIVATING || le_status == BT_LE_DEACTIVATING) {
+ BT_ERR("Disabling in progress");
+ return BLUETOOTH_ERROR_DEVICE_BUSY;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_enable_adapter(void)
{
GDBusProxy *proxy;
if (le_status == BT_LE_ACTIVATED) {
BT_INFO("LE Already enabled. Just turn on PSCAN");
ret = _bt_set_connectable(TRUE);
- if (ret == BLUETOOTH_ERROR_NONE) {
+ if (ret == BLUETOOTH_ERROR_NONE)
_bt_adapter_set_status(BT_ACTIVATED);
- } else {
+ else
return BLUETOOTH_ERROR_INTERNAL;
- }
}
result = g_dbus_proxy_call_sync(proxy, "EnableAdapter",
G_DBUS_CALL_FLAGS_NONE, BT_ENABLE_TIMEOUT,
NULL, &error);
if (error) {
- BT_ERR("EnableAdapterLe failed: %s", error->message);
- _bt_adapter_set_status(BT_DEACTIVATED);
+ BT_ERR("EnableAdapterLe failed: %s", error->message);
+ _bt_adapter_set_status(BT_DEACTIVATED);
g_clear_error(&error);
error = NULL;
result = g_dbus_proxy_call_sync(proxy,
g_clear_error(&error);
}
g_variant_unref(result);
+#ifndef USB_BLUETOOTH
/* Terminate myself */
g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
+#endif
return BLUETOOTH_ERROR_INTERNAL;
}
g_variant_unref(result);
- if (le_status == BT_LE_ACTIVATED) {
+ if (le_status == BT_LE_ACTIVATED)
__bt_set_enabled();
- } else {
+ else
_bt_adapter_start_enable_timer();
- }
return BLUETOOTH_ERROR_NONE;
}
BT_DBG("");
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
device_list = g_array_new(FALSE, FALSE, sizeof(gchar));
return ret;
}
+#if 0
static gboolean __bt_set_disabled_timeout_cb(gpointer user_data)
{
BT_DBG("");
return FALSE;
}
+#endif
-int __bt_disable_cb(void)
+int _bt_disable_cb(void)
{
FN_START;
GDBusProxy *proxy;
- bt_le_status_t le_status;
+#if 0
int ret;
+#endif
GVariant *result;
GError *error = NULL;
_bt_adapter_set_status(BT_DEACTIVATING);
+#if 0
+ bt_le_status_t le_status;
le_status = _bt_adapter_get_le_status();
BT_DBG("le_status : %d", le_status);
if (le_status == BT_LE_ACTIVATED) {
}
}
}
-
+#endif
proxy = __bt_get_core_proxy();
retv_if(!proxy, BLUETOOTH_ERROR_INTERNAL);
return BLUETOOTH_ERROR_NONE;
}
+int _bt_disable_adapter_check_status(void)
+{
+ bt_status_t status = _bt_adapter_get_status();
+
+ BT_DBG("");
+
+ if (status == BT_DEACTIVATING) {
+ BT_DBG("Disabling in progress");
+ return BLUETOOTH_ERROR_IN_PROGRESS;
+ }
+
+ if (status == BT_DEACTIVATED) {
+ BT_DBG("Already disabled");
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_disable_adapter(void)
{
BT_DBG("+");
}
__bt_disconnect_all();
- ret = __bt_disable_cb();
+ ret = _bt_disable_cb();
BT_DBG("-");
return ret;
return BLUETOOTH_ERROR_INTERNAL;
}
+ is_recovery_mode = TRUE;
+
g_variant_unref(result);
__bt_disconnect_all();
g_variant_unref(result);
/* Terminate myself */
- if (_bt_adapter_get_status() == BT_DEACTIVATED) {
+ if (_bt_adapter_get_status() == BT_DEACTIVATED)
g_idle_add((GSourceFunc)_bt_terminate_service, NULL);
- }
return BLUETOOTH_ERROR_NONE;
}
address = g_variant_get_string(temp, NULL);
BT_DBG("Address:%s", address);
- if (address) {
+ if (address)
_bt_convert_addr_string_to_type(local_address->addr, address);
- } else {
+ else
return BLUETOOTH_ERROR_INTERNAL;
- }
g_variant_unref(result);
g_variant_unref(temp);
GError *error = NULL;
int ret = BLUETOOTH_ERROR_NONE;
GVariant *result;
- GVariant *value;
+ GVariant *temp = NULL;
GVariantIter *iter = NULL;
- gchar *uuid;
+ gchar *uuid = NULL;
BT_DBG("+");
BT_CHECK_PARAMETER(service_uuid, return);
return BLUETOOTH_ERROR_INTERNAL;
}
- g_variant_get(result, "(v)", &value);
- g_variant_get(value, "as", &iter);
- if (iter == NULL) {
- BT_ERR("Failed to get UUIDs(%s)", service_uuid);
- *used = FALSE;
- g_variant_unref(result);
- g_variant_unref(value);
- return ret;
- }
+ g_variant_get(result, "(v)", &temp);
+ g_variant_get(temp, "as", &iter);
- while (g_variant_iter_loop(iter, "s", &uuid)) {
+ *used = FALSE;
+ while (g_variant_iter_loop(iter, "&s", &uuid)) {
if (strcasecmp(uuid, service_uuid) == 0) {
*used = TRUE;
- g_free(uuid);
- goto done;
+ break;
}
}
-
- *used = FALSE;
-
-done:
g_variant_iter_free(iter);
- g_variant_unref(value);
g_variant_unref(result);
+
BT_DBG("Service Used? %d", *used);
+
return ret;
}
&error);
if (!result) {
+ int ret = BLUETOOTH_ERROR_INTERNAL;
if (error != NULL) {
BT_ERR("StopDiscovery failed (Error: %s)", error->message);
+
+ if (g_strrstr(error->message, "No discovery started"))
+ ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
+
g_clear_error(&error);
- } else
+ } else {
BT_ERR("StopDiscovery failed");
- return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return ret;
}
cancel_by_user = TRUE;
return BLUETOOTH_ERROR_INTERNAL;
}
- BT_INFO("Set connectable [%d]", is_connectable);
+ BT_INFO("### Set connectable [%d]", is_connectable);
g_variant_unref(result);
return BLUETOOTH_ERROR_NONE;
}
g_strlcpy(dev_info->device_name.name, alias,
BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
}
+ } else if (!g_strcmp0(key, "IsAliasSet")) {
+ dev_info->is_alias_set = g_variant_get_boolean(value);
} else if (!g_strcmp0(key, "Connected")) {
dev_info->connected = g_variant_get_byte(value);
} else if (!g_strcmp0(key, "Paired")) {
} else if (strcasecmp(key, "ManufacturerData") == 0) {
manufacturer_data = g_byte_array_new();
g_variant_get(value, "ay", &char_value_iter);
-
while (g_variant_iter_loop(char_value_iter, "y", &char_value))
g_byte_array_append(manufacturer_data, &char_value, 1);
if (manufacturer_data) {
- if (manufacturer_data->len > 0) {
+ if (manufacturer_data->len > 0)
memcpy(dev_info->manufacturer_data.data, manufacturer_data->data, manufacturer_data->len);
- }
}
g_variant_iter_free(char_value_iter);
g_byte_array_free(manufacturer_data, TRUE);
GVariantIter *iter = NULL;
GError *error = NULL;
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
manager_proxy = _bt_get_manager_proxy();
return BLUETOOTH_ERROR_NONE;
}
+int _bt_get_profile_connected_devices(char *profile_uuid, GArray **addr_list)
+{
+ BT_DBG("+");
+ GDBusConnection *conn;
+ GDBusProxy *manager_proxy;
+ GVariant *result = NULL;
+ GVariant *result1 = NULL;
+ GVariantIter *iter = NULL;
+ GError *error = NULL;
+ char *object_path = NULL;
+ GVariantIter *interface_iter;
+ char *interface_str = NULL;
+ GDBusProxy *device_proxy = NULL;
+ gboolean is_connected = FALSE;
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ manager_proxy = _bt_get_manager_proxy();
+ retv_if(manager_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ NULL);
+
+ if (!result) {
+ if (error != NULL) {
+ BT_ERR("Failed to GetManagedObjects (Error: %s)", error->message);
+ g_clear_error(&error);
+ error = NULL;
+ } else
+ BT_ERR("Failed to Failed to GetManagedObjects");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ /* signature of GetManagedObjects: a{oa{sa{sv}}} */
+ g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
+
+ /* Parse the signature: oa{sa{sv}}} */
+ while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path, &interface_iter)) {
+ if (object_path == NULL)
+ continue;
+
+ while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
+ &interface_str, NULL)) {
+ if (g_strcmp0(interface_str, "org.bluez.Device1") == 0) {
+ BT_DBG("Found a device: %s", object_path);
+ g_free(interface_str);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ object_path, BT_DEVICE_INTERFACE, NULL, NULL);
+
+ if (device_proxy == NULL) {
+ BT_DBG("Device don't have this service");
+ break;
+ }
+
+ result1 = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
+ g_variant_new("(s)", profile_uuid),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (result1 == NULL) {
+ BT_ERR("Error occured in Proxy call");
+ if (error) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ error = NULL;
+ }
+ g_object_unref(device_proxy);
+ break;
+ }
+ g_variant_get(result1, "(b)", &is_connected);
+
+ if (is_connected == TRUE) {
+ char address[BT_ADDRESS_STRING_SIZE];
+ bluetooth_device_address_t *addr = NULL;
+
+ _bt_convert_device_path_to_address(object_path, address);
+
+ addr = g_malloc0(sizeof(bluetooth_device_address_t));
+ _bt_convert_addr_string_to_type(addr->addr, address);
+
+ g_array_append_vals(*addr_list, addr,
+ sizeof(bluetooth_device_address_t));
+ }
+
+ g_variant_unref(result1);
+ g_object_unref(device_proxy);
+
+ break;
+ }
+ }
+ }
+
+ g_variant_unref(result);
+ g_variant_iter_free(iter);
+
+ BT_DBG("-");
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_get_bonded_device_info(bluetooth_device_address_t *device_address,
bluetooth_device_info_t *dev_info)
{
return ret;
}
+int _bt_is_alias_set(bluetooth_device_address_t *device_address, gboolean *is_alias_set)
+{
+ char *object_path = NULL;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ gboolean alias_set = FALSE;
+
+ GDBusConnection *conn;
+ GDBusProxy *device_proxy;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GVariant *temp = NULL;
+
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_PARAMETER(is_alias_set, return);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ object_path = _bt_get_device_object_path(address);
+ retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
+
+ conn = _bt_gdbus_get_system_gconn();
+ if (conn == NULL) {
+ g_free(object_path);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL,
+ BT_BLUEZ_NAME,
+ object_path,
+ BT_PROPERTIES_INTERFACE,
+ NULL, NULL);
+ if (device_proxy == NULL) {
+ g_free(object_path);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ result = g_dbus_proxy_call_sync(device_proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "IsAliasSet"),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (!result) {
+ BT_ERR("Error occured in Proxy call");
+ if (error != NULL) {
+ BT_ERR("Getting is_alias_set property failed: [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(device_proxy);
+ g_free(object_path);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_variant_get(result, "(v)", &temp);
+ alias_set = g_variant_get_boolean(temp);
+ *is_alias_set = alias_set;
+ BT_DBG("address: [%s] | *is_alias_set: %s", address, *is_alias_set ? "TRUE" : "FALSE");
+ g_variant_unref(temp);
+ g_variant_unref(result);
+ g_object_unref(device_proxy);
+
+ g_free(object_path);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_get_timeout_value(int *timeout)
{
time_t current_time;
return BLUETOOTH_ERROR_NONE;
}
+int _bt_set_le_static_random_address(gboolean is_enable)
+{
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ GVariant *result = NULL;
+
+ if (__bt_is_factory_test_mode()) {
+ BT_ERR("Unable to set le random address in factory binary !!");
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (_bt_adapter_get_status() != BT_ACTIVATED &&
+ _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ proxy = _bt_get_adapter_proxy();
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(proxy,
+ "SetLeStaticRandomAddress",
+ g_variant_new("(b)", is_enable),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (!result) {
+ if (error != NULL) {
+ BT_ERR("Failed to SetLeStaticRandomAddress (Error: %s)", error->message);
+ g_clear_error(&error);
+ } else
+ BT_ERR("Failed to SetLeStaticRandomAddress");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_variant_unref(result);
+ BT_INFO("SetLeStaticRandomAddress as %d", is_enable);
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_set_manufacturer_data(bluetooth_manufacturer_data_t *m_data)
{
GDBusProxy *proxy;
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < (m_data->data_len) + 2; i++) {
+ for (i = 0; i < (m_data->data_len) + 2; i++)
g_variant_builder_add(builder, "y", m_data->data[i]);
- }
val = g_variant_new("(ay)", builder);
}
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < (m_data->data_len) + 2; i++) {
+ for (i = 0; i < (m_data->data_len) + 2; i++)
g_variant_builder_add(builder, "y", m_data->data[i]);
- }
val = g_variant_new("(ay)", builder);
return BLUETOOTH_ERROR_NONE;
}
+
+int _bt_service_set_alarm(int timeout, bt_set_alarm_cb call_back, void *user_data, alarm_id_t *alarm_id)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ bt_service_alarm_t *alarm = NULL;
+
+ if (!call_back || !alarm_id)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (!alarm_mgr.is_alarm_initialized) {
+ result = alarmmgr_init("bt-service");
+ if (result != 0) {
+ BT_ERR("Failed to initialize alarm = %d", result);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ goto finish;
+ }
+ result = alarmmgr_set_cb(alarm_cb, NULL);
+ if (result != 0) {
+ BT_ERR("Failed to set the callback = %d", result);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ goto finish;
+ }
+ alarm_mgr.is_alarm_initialized = TRUE;
+ }
+
+ alarm = g_malloc0(sizeof(bt_service_alarm_t));
+ if (!alarm)
+ return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+
+ result = alarmmgr_add_alarm(ALARM_TYPE_VOLATILE, timeout,
+ 0, NULL, alarm_id);
+ if (result != 0) {
+ BT_ERR("Failed to create alarm error = %d", result);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ g_free(alarm);
+ goto finish;
+ }
+ alarm->alarm_id = *alarm_id;
+ alarm->callback = call_back;
+ alarm->user_data = user_data;
+
+ alarm_mgr.g_alarm_list = g_list_append(alarm_mgr.g_alarm_list, alarm);
+ result = BLUETOOTH_ERROR_NONE;
+finish:
+ return result;
+}
+
+static int alarm_cb(alarm_id_t alarm_id, void* user_param)
+{
+ GList *node = NULL;
+ bt_service_alarm_t *p_data;
+ bt_set_alarm_cb callback = NULL;
+ void *user_data = NULL;
+
+ node = g_list_find_custom(alarm_mgr.g_alarm_list,
+ GINT_TO_POINTER(alarm_id), compare_alarm);
+ if (!node)
+ return 0;
+
+ p_data = (bt_service_alarm_t *)node->data;
+ alarm_mgr.g_alarm_list = g_list_delete_link(alarm_mgr.g_alarm_list,
+ node);
+
+ if (!p_data)
+ return 0;
+
+ callback = p_data->callback;
+ user_data = p_data->user_data;
+ g_free(p_data);
+
+ if (callback)
+ callback(alarm_id, user_data);
+
+ return 0;
+}
+
+int _bt_service_remove_alarm(alarm_id_t alarm_id)
+{
+ GList *list = NULL;
+ bt_service_alarm_t *p_data;
+ list = g_list_find_custom(alarm_mgr.g_alarm_list, GINT_TO_POINTER(alarm_id), compare_alarm);
+
+ if (list != NULL) {
+ alarmmgr_remove_alarm(alarm_id);
+ p_data = (bt_service_alarm_t *)list->data;
+ alarm_mgr.g_alarm_list = g_list_remove(alarm_mgr.g_alarm_list, list->data);
+ g_free(p_data);
+ }
+
+ return 0;
+}
+
+gint compare_alarm(gconstpointer list_data, gconstpointer data)
+{
+ alarm_id_t alarm_id = (alarm_id_t)data;
+ bt_service_alarm_t *p_data = (bt_service_alarm_t *)list_data;
+
+ if (p_data->alarm_id == alarm_id)
+ return 0;
+
+ return 1;
+}
+
+static void alarm_data_free(void *data)
+{
+ bt_service_alarm_t *p_data = (bt_service_alarm_t *)data;
+ g_free(p_data);
+ return;
+}
+
+static gboolean _bt_adapter_request_delayed_cb(gpointer user_data)
+{
+ int result;
+ int function = (int)user_data;
+
+ switch (function) {
+ case BT_ENABLE_ADAPTER:
+ result = _bt_enable_adapter();
+ if (result != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("_bt_enable_adapter is failed");
+ /* Send enabled event to API */
+ _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_ENABLED,
+ g_variant_new("(i)", result));
+ }
+ break;
+ case BT_DISABLE_ADAPTER:
+ result = _bt_disable_adapter();
+ if (result != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("_bt_disable_adapter is failed");
+ /* Send disabled event to API */
+ _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISABLED,
+ g_variant_new("(i)", result));
+ }
+ break;
+ default:
+ BT_ERR("function is NOT matched");
+ break;
+ }
+
+ return FALSE;
+}
+
+int _bt_adapter_request_delayed(int function)
+{
+ int ret;
+
+ switch (function) {
+ case BT_ENABLE_ADAPTER:
+ ret = _bt_enable_adapter_check_status();
+ if (ret == BLUETOOTH_ERROR_NONE)
+ _bt_adapter_set_status(BT_ACTIVATING);
+ else
+ return ret;
+
+ break;
+ case BT_DISABLE_ADAPTER:
+ ret = _bt_disable_adapter_check_status();
+ if (ret == BLUETOOTH_ERROR_NONE)
+ _bt_adapter_set_status(BT_DEACTIVATING);
+ else
+ return ret;
+
+ break;
+ default:
+ BT_ERR("function is NOT matched");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_idle_add((GSourceFunc)_bt_adapter_request_delayed_cb, (void*)function);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
#ifdef TIZEN_TV
int _bt_get_enable_timer_id(void)
{
#include <string.h>
#include <malloc.h>
#include <stacktrim.h>
-
-#if defined(LIBNOTIFY_SUPPORT)
-#include "bt-popup.h"
-#elif defined(LIBNOTIFICATION_SUPPORT)
-#include "bt-service-agent-notification.h"
-#else
#include <syspopup_caller.h>
-#endif
-
#include <vconf.h>
#include <bundle_internal.h>
-#ifdef TIZEN_NETWORK_TETHERING_ENABLE
+#ifdef TIZEN_FEATURE_NETWORK_TETHERING_ENABLE
#include <tethering.h>
#endif
#define GN_UUID "00001117-0000-1000-8000-00805f9b34fb"
#define BNEP_UUID "0000000f-0000-1000-8000-00805f9b34fb"
#define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
+#define HID_DEVICE_UUID "00001124-0000-1000-8000-00805f9b43bf"
#define SAP_UUID_OLD "a49eb41e-cb06-495c-9f4f-bb80a90cdf00"
#define SAP_UUID_NEW "a49eb41e-cb06-495c-9f4f-aa80a90cdf4a"
+#define IOTIVITY_UUID "12341234-1C25-481F-9DFB-59193D238280"
#define BT_AGENT_OBJECT "/org/bluez/agent/frwk_agent"
#define BT_AGENT_SIGNAL_RFCOMM_AUTHORIZE "RfcommAuthorize"
#define BT_AGENT_SIGNAL_OBEX_AUTHORIZE "ObexAuthorize"
-#define BT_PIN_MAX_LENGTH 16
#define BT_PASSKEY_MAX_LENGTH 4
#define BT_AGENT_SYSPOPUP_TIMEOUT_FOR_MULTIPLE_POPUPS 200
#define BT_AGENT_SYSPOPUP_MAX_ATTEMPT 3
#define BT_PAN_MAX_CONNECTION 4
+
extern guint nap_connected_device_count;
+static char *passkey_watcher = NULL;
+
#define G_VARIANT_UNREF(variant) \
g_variant_unref(variant); \
variant = NULL
-static gboolean syspopup_mode = TRUE;
-
static int __bt_agent_is_auto_response(uint32_t dev_class, const gchar *address,
const gchar *name);
static gboolean __bt_agent_is_hid_keyboard(uint32_t dev_class);
/* Release Stack Memory*/
stack_trim();
}
-
static gboolean __bt_agent_system_popup_timer_cb(gpointer user_data)
{
int ret;
retv_if(user_data == NULL, FALSE);
++retry_count;
-#if defined(LIBNOTIFY_SUPPORT)
- ret = notify_launch(b);
-#elif defined(LIBNOTIFICATION_SUPPORT)
- ret = notification_launch(b);
-#else
- ret = syspopup_launch("bt-syspopup", b);
-#endif
+
+ ret = syspopup_launch("bt-syspopup", b);
if (ret < 0) {
BT_ERR("Sorry! Can't launch popup, ret=%d, Re-try[%d] time..",
ret, retry_count);
return (ret < 0) ? TRUE : FALSE;
}
-#ifdef TIZEN_WEARABLE
-static void __bt_popup_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)
-{
- BT_DBG("Sender Name[%s] Object Path[%s] Interface[%s] Signal[%s]",
- sender_name, object_path, interface_name, signal_name);
-
- if (g_strcmp0(interface_name, "User.Bluetooth.syspopup") == 0 &&
- g_strcmp0(signal_name, "ResetResponse") == 0) {
- int response;
-
- g_variant_get(parameters, "(i)", &response);
- BT_DBG("response = %d", response);
- }
-}
-
-int __bt_service_subscribe_popup(GDBusConnection *conn,
- gboolean subscribe)
-{
- static guint subs_interface_added_id = 0;
-
- if (conn == NULL)
- return BLUETOOTH_ERROR_INVALID_PARAM;
-
- if (subscribe) {
- if (subs_interface_added_id == 0) {
- subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
- NULL, "User.Bluetooth.syspopup", "ResetResponse", NULL, NULL, 0,
- __bt_popup_event_filter, NULL, NULL);
- }
- } else {
- if (subs_interface_added_id > 0) {
- g_dbus_connection_signal_unsubscribe(conn,
- subs_interface_added_id);
- subs_interface_added_id = 0;
- }
- }
- return BLUETOOTH_ERROR_NONE;
-}
-
-static void __bt_register_popup_event_signal(void)
-{
- GDBusConnection *conn;
-
- BT_DBG("+\n");
-
- conn = _bt_get_system_gconn();
- if (conn == NULL)
- return;
-
- __bt_service_subscribe_popup(conn, TRUE);
-
- BT_DBG("-\n");
- return;
-}
-
-static gboolean __is_reset_required(const gchar *address)
-{
- GArray *device_list;
- uint32_t no_of_device;
- uint32_t i;
- bluetooth_device_info_t info;
- gboolean is_required = FALSE;
-
- device_list = g_array_new(FALSE, FALSE, sizeof(gchar));
- if (device_list == NULL) {
- BT_ERR("g_array_new is failed");
- return FALSE;
- }
-
- if (_bt_get_bonded_devices(&device_list) != BLUETOOTH_ERROR_NONE) {
- BT_ERR("_bt_get_bonded_devices is failed");
- g_array_free(device_list, TRUE);
- return FALSE;
- }
-
- no_of_device = device_list->len / sizeof(bluetooth_device_info_t);
- for (i = 0; i < no_of_device; i++) {
- char addr[BT_ADDRESS_STRING_SIZE] = { 0 };
-
- info = g_array_index(device_list, bluetooth_device_info_t, i);
-
- _bt_convert_addr_type_to_string(addr, info.device_address.addr);
- if (g_strcmp0(address, addr) == 0) {
- BT_DBG("This device is already in paired list");
- is_required = FALSE;
- break;
- }
-
- if (info.device_class.major_class != BLUETOOTH_DEVICE_MAJOR_CLASS_AUDIO) {
- is_required = TRUE;
- break;
- }
- }
- g_array_free(device_list, TRUE);
-
- return is_required;
-}
-#endif
-
int _bt_launch_system_popup(bt_agent_event_type_t event_type,
const char *device_name,
+ const unsigned char *auth_info,
char *passkey,
const char *filename,
const char *agent_path)
}
bundle_add(b, "device-name", device_name);
+ bundle_add(b, "auth-info", (const char *)auth_info);
bundle_add(b, "passkey", passkey);
bundle_add(b, "file", filename);
bundle_add(b, "agent-path", agent_path);
sizeof(event_str));
break;
- case BT_AGENT_EVENT_PASSKEY_AUTO_ACCEPTED:
- g_strlcpy(event_str, "passkey-auto-accepted",
- sizeof(event_str));
- break;
-
case BT_AGENT_EVENT_PASSKEY_REQUEST:
g_strlcpy(event_str, "passkey-request", sizeof(event_str));
break;
g_strlcpy(event_str, "message-request", sizeof(event_str));
break;
-#ifdef TIZEN_WEARABLE
- case BT_AGENT_EVENT_SYSTEM_RESET_REQUEST:
- __bt_register_popup_event_signal();
- g_strlcpy(event_str, "system-reset-request", sizeof(event_str));
- break;
-#endif
-
case BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE:
g_strlcpy(event_str, "remote-legacy-pair-failed", sizeof(event_str));
break;
bundle_add(b, "event-type", event_str);
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
ret = syspopup_launch("bt-syspopup", b);
-#endif
if (0 > ret) {
BT_ERR("Popup launch failed...retry %d", ret);
static gboolean __pincode_request(GapAgentPrivate *agent, GDBusProxy *device)
{
uint32_t device_class;
- const gchar *address;
- const gchar *name;
+ gchar *address = NULL;
+ unsigned char auth_info[5] = {0, };
+ gchar *name = NULL;
GVariant *reply = NULL;
GVariant *reply_temp = NULL;
GVariant *tmp_value;
- GVariant *param;
- int result = BLUETOOTH_ERROR_NONE;
+ char pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH + 1];
BT_DBG("+");
tmp_value = g_variant_lookup_value(reply, "Name", G_VARIANT_TYPE_STRING);
g_variant_get(tmp_value, "s", &name);
G_VARIANT_UNREF(tmp_value);
- if (!name)
- name = address;
+ if (!name) {
+ BT_DBG("Replacing the name with address");
+ name = g_strdup(address);
+ } else {
+ BT_INFO("Name = %s, Address = %s, Class = 0x%x", name, address, device_class);
+ if (name[0] == '\0') {
+ g_free(name);
+ BT_DBG("Name[0]=NULL, Replacing the name with address");
+ name = g_strdup(address);
+ }
+ }
+ __bt_get_auth_info(reply, (char *)auth_info);
if (_bt_is_device_creating() == TRUE &&
_bt_is_bonding_device_address(address) == TRUE &&
__bt_agent_is_auto_response(device_class, address, name)) {
gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT,
str_passkey, NULL);
-#ifdef AUTO_ACCEPT
- gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, "0000",
- NULL);
-#else
- if (syspopup_mode) {
- BT_DBG("LAUNCH SYSPOPUP");
- _bt_launch_system_popup(BT_AGENT_EVENT_KEYBOARD_PASSKEY_REQUEST,
- name, str_passkey, NULL,
- _gap_agent_get_path(agent));
- } else {
- BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
- param = g_variant_new("(isss)", result, address, name, str_passkey);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
- }
-#endif
+ _bt_launch_system_popup(BT_AGENT_EVENT_KEYBOARD_PASSKEY_REQUEST,
+ name, auth_info, str_passkey, NULL,
+ _gap_agent_get_path(agent));
+ } else if (_bt_get_device_pin_code(address, pin_code)
+ == BLUETOOTH_ERROR_NONE) {
+ BT_DBG("Use stored PIN code(%s)", pin_code);
+ gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, pin_code,
+ NULL);
+ goto done;
} else {
BT_DBG("Show Pin entry");
-
- if (syspopup_mode) {
- BT_DBG("LAUNCH SYSPOPUP");
- _bt_launch_system_popup(BT_AGENT_EVENT_PIN_REQUEST, name, NULL,
- NULL, _gap_agent_get_path(agent));
- } else {
- BT_DBG("Send BLUETOOTH_EVENT_PIN_REQUEST");
- param = g_variant_new("(iss)", result, address, name);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_PIN_REQUEST, param);
- }
+ _bt_launch_system_popup(BT_AGENT_EVENT_PIN_REQUEST, name, auth_info,
+ NULL, NULL, _gap_agent_get_path(agent));
}
done:
g_variant_unref(reply);
g_variant_unref(reply_temp);
+ g_free(address);
+ g_free(name);
__bt_agent_release_memory();
BT_DBG("-");
static gboolean __passkey_request(GapAgentPrivate *agent, GDBusProxy *device)
{
- const gchar *address;
- const gchar *name;
+ gchar *address = NULL;
+ gchar *name = NULL;
+ unsigned char auth_info[5] = {0, };
GVariant *reply = NULL;
GVariant *reply_temp = NULL;
GVariant *tmp_value;
g_variant_get(tmp_value, "s", &name);
G_VARIANT_UNREF(tmp_value);
if (!name)
- name = address;
-
-#ifdef AUTO_ACCEPT
- gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, "0000",
- NULL);
-#else
- if (syspopup_mode) {
- BT_DBG("LAUNCH SYSPOPUP");
- _bt_launch_system_popup(BT_AGENT_EVENT_PASSKEY_REQUEST, name, NULL, NULL,
- _gap_agent_get_path(agent));
- } else {
- int result = BLUETOOTH_ERROR_NONE;
- GVariant *param;
+ name = g_strdup(address);
- BT_DBG("Send BLUETOOTH_EVENT_PASSKEY_REQUEST");
- param = g_variant_new("(iss)", result, address, name);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_PASSKEY_REQUEST, param);
- }
-#endif
+ __bt_get_auth_info(reply, (char *)auth_info);
+
+ _bt_launch_system_popup(BT_AGENT_EVENT_PASSKEY_REQUEST, name, auth_info,
+ NULL, NULL, _gap_agent_get_path(agent));
done:
g_variant_unref(reply);
g_variant_unref(reply_temp);
+ g_free(address);
+ g_free(name);
__bt_agent_release_memory();
BT_DBG("-");
static gboolean __display_request(GapAgentPrivate *agent, GDBusProxy *device,
guint passkey)
{
- const gchar *address;
- const gchar *name;
+ gchar *address = NULL;
+ gchar *name = NULL;
+ unsigned char auth_info[5] = {0, };
char *str_passkey;
GVariant *reply = NULL;
GVariant *reply_temp = NULL;
g_variant_get(tmp_value, "s", &name);
G_VARIANT_UNREF(tmp_value);
if (!name)
- name = address;
+ name = g_strdup(address);
- str_passkey = g_strdup_printf("%d", passkey);
+ __bt_get_auth_info(reply, (char *)auth_info);
-#ifdef AUTO_ACCEPT
- gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, str_passkey,
- NULL);
-#else
- if (syspopup_mode) {
- BT_DBG("LAUNCH SYSPOPUP");
- _bt_launch_system_popup(BT_AGENT_EVENT_KEYBOARD_PASSKEY_REQUEST, name,
- str_passkey, NULL,
- _gap_agent_get_path(agent));
- } else {
- int result = BLUETOOTH_ERROR_NONE;
- GVariant *param;
+ str_passkey = g_strdup_printf("%06d", passkey);
- BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
- param = g_variant_new("(isss)", result, address, name, str_passkey);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
+ if (passkey_watcher) {
+ GVariant *param = NULL;
+
+ BT_INFO("Send passkey to %s", passkey_watcher);
+
+ param = g_variant_new("(ss)", address, str_passkey);
+
+ _bt_send_event_to_dest(passkey_watcher, BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_PASSKEY_NOTIFICATION, param);
+ } else {
+ _bt_launch_system_popup(BT_AGENT_EVENT_KEYBOARD_PASSKEY_REQUEST, name,
+ auth_info, str_passkey, NULL,
+ _gap_agent_get_path(agent));
}
-#endif
g_free(str_passkey);
done:
g_variant_unref(reply);
g_variant_unref(reply_temp);
+ g_free(address);
+ g_free(name);
__bt_agent_release_memory();
BT_DBG("-");
static gboolean __confirm_request(GapAgentPrivate *agent, GDBusProxy *device,
guint passkey)
{
- const gchar *address;
- const gchar *name;
+ gchar *address = NULL;
+ gchar *name = NULL;
+ unsigned char auth_info[5] = {0, };
char str_passkey[7];
GVariant *reply_temp = NULL;
GVariant *reply = NULL;
g_variant_get(tmp_value, "s", &name);
G_VARIANT_UNREF(tmp_value);
if (!name)
- name = address;
-
-#ifdef TIZEN_WEARABLE
- uint32_t device_class = 0x00;
- uint32_t major_class;
-
- tmp_value = g_variant_lookup_value(reply, "Class", G_VARIANT_TYPE_UINT32);
- g_variant_get(tmp_value, "u", &device_class);
- G_VARIANT_UNREF(tmp_value);
-
- major_class = (device_class & 0x1f00) >> 8;
-
- if (major_class == BLUETOOTH_DEVICE_MAJOR_CLASS_AUDIO) {
- BT_DBG("Audio device. Launch passkey pop-up");
- _bt_launch_system_popup(BT_AGENT_EVENT_PASSKEY_CONFIRM_REQUEST, name,
- str_passkey, NULL, _gap_agent_get_path(agent));
- goto done;
- }
+ name = g_strdup(address);
+ __bt_get_auth_info(reply, (char *)auth_info);
- if (__is_reset_required(address)) {
- BT_INFO("Launch system reset pop-up");
- _bt_launch_system_popup(BT_AGENT_EVENT_SYSTEM_RESET_REQUEST, name,
- NULL, NULL, _gap_agent_get_path(agent));
- } else {
- BT_INFO("Launch passkey pop-up");
- _bt_launch_system_popup(BT_AGENT_EVENT_PASSKEY_AUTO_ACCEPTED, name,
- str_passkey, NULL, _gap_agent_get_path(agent));
-
- gap_agent_reply_confirmation(agent, GAP_AGENT_ACCEPT, NULL);
- }
-#else
-#ifdef AUTO_ACCEPT
- BT_DBG("Confirm reply");
- gap_agent_reply_confirmation(agent, GAP_AGENT_ACCEPT, NULL);
-#else
- if (syspopup_mode) {
- BT_DBG("LAUNCH SYSPOPUP");
- _bt_launch_system_popup(BT_AGENT_EVENT_PASSKEY_CONFIRM_REQUEST, name,
- str_passkey, NULL,
- _gap_agent_get_path(agent));
- } else {
- int result = BLUETOOTH_ERROR_NONE;
- GVariant *param;
-
- BT_DBG("Send BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
- param = g_variant_new("(isss)", result, address, name, str_passkey);
- _bt_send_event(BT_ADAPTER_EVENT,
- BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST, param);
- }
-#endif
-#endif
+ BT_DBG("LAUNCH SYSPOPUP");
+ _bt_launch_system_popup(BT_AGENT_EVENT_PASSKEY_CONFIRM_REQUEST, name,
+ auth_info, str_passkey, NULL,
+ _gap_agent_get_path(agent));
done:
g_variant_unref(reply);
g_variant_unref(reply_temp);
+ g_free(address);
+ g_free(name);
__bt_agent_release_memory();
BT_DBG("-");
{
BT_DBG("On Going Pairing is cancelled by remote\n");
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
syspopup_destroy_all();
-#endif
__bt_agent_release_memory();
static gboolean __authorize_request(GapAgentPrivate *agent, GDBusProxy *device,
const char *uuid)
{
- const gchar *address;
- const gchar *name;
+ gchar *address = NULL;
+ gchar *name = NULL;
+ unsigned char auth_info[5] = {0, };
gboolean trust;
- gboolean paired;
GVariant *reply = NULL;
GVariant *reply_temp = NULL;
GVariant *tmp_value;
-#ifdef TIZEN_NETWORK_TETHERING_ENABLE
+#ifdef TIZEN_FEATURE_NETWORK_TETHERING_ENABLE
bool enabled;
tethering_h tethering = NULL;
#endif
int result = BLUETOOTH_ERROR_NONE;
-#ifndef AUTO_ACCEPT
int request_type = BT_AGENT_EVENT_AUTHORIZE_REQUEST;
-#endif
BT_DBG("+");
-#ifdef AUTO_ACCEPT
- gap_agent_reply_authorize(agent, GAP_AGENT_ACCEPT,
- NULL);
- goto done;
-#endif
-
/* Check if already Media connection exsist */
if (!strcasecmp(uuid, A2DP_UUID)) {
gboolean ret = FALSE;
!strcasecmp(uuid, HSP_HS_UUID) ||
!strcasecmp(uuid, A2DP_UUID) ||
!strcasecmp(uuid, HID_UUID) ||
+ !strcasecmp(uuid, HID_DEVICE_UUID) ||
!strcasecmp(uuid, SAP_UUID_OLD) ||
!strcasecmp(uuid, SAP_UUID_NEW) ||
+ !strcasecmp(uuid, IOTIVITY_UUID) ||
!strcasecmp(uuid, AVRCP_TARGET_UUID)) {
BT_DBG("Auto accept authorization for audio device (HFP, A2DP, AVRCP) [%s]", uuid);
gap_agent_reply_authorize(agent, GAP_AGENT_ACCEPT,
!strcasecmp(uuid, BNEP_UUID)) {
BT_DBG("Network connection request: %s", uuid);
-#ifdef TIZEN_NETWORK_TETHERING_ENABLE
+#ifdef TIZEN_FEATURE_NETWORK_TETHERING_ENABLE
if (nap_connected_device_count >=
BT_PAN_MAX_CONNECTION) {
BT_ERR("Max connection exceeded");
ret = tethering_destroy(tethering);
- if (ret != TETHERING_ERROR_NONE) {
+ if (ret != TETHERING_ERROR_NONE)
BT_ERR("Fail to create tethering: %d", ret);
- }
if (enabled != true) {
BT_ERR("BT tethering is not enabled");
gap_agent_reply_authorize(agent, GAP_AGENT_ACCEPT,
NULL);
goto done;
-#ifdef TIZEN_NETWORK_TETHERING_ENABLE
+#ifdef TIZEN_FEATURE_NETWORK_TETHERING_ENABLE
fail:
gap_agent_reply_authorize(agent, GAP_AGENT_REJECT,
NULL);
g_variant_get(tmp_value, "s", &name);
G_VARIANT_UNREF(tmp_value);
if (!name)
- name = address;
+ name = g_strdup(address);
tmp_value = g_variant_lookup_value(reply, "Trusted", G_VARIANT_TYPE_BOOLEAN);
g_variant_get(tmp_value, "b", &trust);
G_VARIANT_UNREF(tmp_value);
- tmp_value = g_variant_lookup_value(reply, "Paired", G_VARIANT_TYPE_BOOLEAN);
- g_variant_get(tmp_value, "b", &paired);
- G_VARIANT_UNREF(tmp_value);
- if ((paired == FALSE) && (trust == FALSE)) {
- BT_ERR("No paired & No trusted device");
- gap_agent_reply_authorize(agent,
- GAP_AGENT_REJECT, NULL);
- goto done;
- }
+ __bt_get_auth_info(reply, (char *)auth_info);
BT_INFO("Authorization request for device [%s] Service:[%s]\n", address, uuid);
goto done;
}
+ if (!strcasecmp(uuid, OPP_UUID))
+ request_type = BT_AGENT_EVENT_EXCHANGE_REQUEST;
+ else if (!strcasecmp(uuid, PBAP_UUID))
+ request_type = BT_AGENT_EVENT_PBAP_REQUEST;
+ else if (!strcasecmp(uuid, MAP_UUID))
+ request_type = BT_AGENT_EVENT_MAP_REQUEST;
+
if (trust) {
BT_INFO("Trusted device, so authorize\n");
gap_agent_reply_authorize(agent,
- GAP_AGENT_ACCEPT, NULL);
+ GAP_AGENT_ACCEPT, NULL);
} else {
-#ifdef AUTO_ACCEPT
- gap_agent_reply_authorize(agent, GAP_AGENT_ACCEPT, NULL);
-#else
- if (!strcasecmp(uuid, OPP_UUID))
- request_type = BT_AGENT_EVENT_EXCHANGE_REQUEST;
- else if (!strcasecmp(uuid, PBAP_UUID))
- request_type = BT_AGENT_EVENT_PBAP_REQUEST;
- else if (!strcasecmp(uuid, MAP_UUID))
- request_type = BT_AGENT_EVENT_MAP_REQUEST;
-
- _bt_launch_system_popup(request_type, name, NULL, NULL,
- _gap_agent_get_path(agent));
-#endif
+ _bt_launch_system_popup(request_type, name, auth_info, NULL, NULL,
+ _gap_agent_get_path(agent));
}
done:
- g_variant_unref(reply);
- g_variant_unref(reply_temp);
+ if (reply)
+ g_variant_unref(reply);
+
+ if (reply_temp)
+ g_variant_unref(reply_temp);
+
+ g_free(name);
+ g_free(address);
__bt_agent_release_memory();
BT_DBG("-");
gap_agent_reply_authorize(agent, GAP_AGENT_CANCEL, NULL);
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
syspopup_destroy_all();
-#endif
__bt_agent_release_memory();
return 0;
}
+
+int _bt_set_passkey_notification(const char *sender, gboolean enable)
+{
+ BT_INFO("Set passkey notification(sender:%s, %s)",
+ sender, enable ? "Enable" : "Disable");
+
+ g_free(passkey_watcher);
+ if (enable == TRUE)
+ passkey_watcher = g_strdup(sender);
+ else
+ passkey_watcher = NULL;
+
+ return BLUETOOTH_ERROR_NONE;
+}
#include <glib.h>
#include <dlog.h>
#include <string.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
-#include <syspopup_caller.h>
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+#include <vconf.h>
#endif
+#include <syspopup_caller.h>
#include "bluetooth-api.h"
#include "bt-internal-types.h"
#include "bt-service-headset-connection.h"
#ifdef TIZEN_SUPPORT_DUAL_HF
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
#define VCONF_KEY_BT_HOST_BT_MAC_ADDR "db/wms/host_bt_mac"
#endif
#endif
char device_address[BT_ADDRESS_STRING_SIZE + 1];
} bt_connected_headset_data_t;
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+typedef struct {
+ int alarm_id;
+ int retry_count;
+} bt_auto_connect_timer_t;
+
+bt_auto_connect_timer_t auto_connect_timer = {0, };
+#endif
+
static GList *g_connected_list;
static bt_headset_wait_t *g_wait_data;
static gboolean __bt_device_support_uuid(char *remote_address,
bt_audio_type_t type);
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+static int __bt_auto_connect_alarm_cb(alarm_id_t alarm_id, void* user_param);
+#endif
+
static void __bt_hf_request_cb(GDBusProxy *proxy, GAsyncResult *res,
gpointer user_data)
{
if (reply == NULL) {
BT_ERR("HF Connect Dbus Call Error");
+ result = _bt_convert_gerror(g_error);
if (g_error) {
BT_ERR("Error: %s\n", g_error->message);
g_clear_error(&g_error);
}
- result = BLUETOOTH_ERROR_INTERNAL;
} else {
g_variant_unref(reply);
}
_bt_audio_connect(pdata->req_id,
BT_AUDIO_A2DP,
&device_address,
- pdata->out_param);
+ NULL);
g_free(pdata->address);
g_free(pdata);
}
if (func_data->pending != BT_PENDING_NONE && g_error == NULL) {
-
bluetooth_device_address_t device_address;
_bt_convert_addr_string_to_type(device_address.addr,
func_data->address);
pdata = g_new0(bt_audio_function_data_t, 1);
pdata->req_id = func_data->req_id;
- pdata->out_param = func_data->out_param;
pdata->address = strdup(func_data->address);
pdata->pending = func_data->pending;
} else
goto check_req_info;
} else {
-
if (_bt_is_service_connected(func_data->address
- , BT_AUDIO_A2DP)) {
+ , BT_AUDIO_HSP)) {
_bt_audio_disconnect(func_data->req_id,
- BT_AUDIO_A2DP,
- &device_address,
- func_data->out_param);
+ BT_AUDIO_HSP, &device_address, NULL);
} else
goto check_req_info;
}
BT_ERR("Audio Connect/Disconnect Dbus Call Error: %s\n", g_error->message);
result = BLUETOOTH_ERROR_INTERNAL;
+ /* If there is error then we need to set local initiated connection as false
+ * If don't do this then when headset initiate connection for HFP then we don't
+ * initiate connection for A2dp to headset as this flag was set to true in first
+ * connection failure attempt and not set in error case.*/
+ _bt_headset_set_local_connection(FALSE);
/* Remove the device from the list */
_bt_remove_headset_from_list(func_data->type, func_data->address);
_bt_convert_addr_string_to_type(device_address.addr,
g_wait_data->address);
_bt_audio_connect(g_wait_data->req_id, g_wait_data->type,
- &device_address, g_wait_data->out_param1);
+ &device_address, NULL);
}
/* Event will be sent by the event reciever */
#ifdef TIZEN_SUPPORT_DUAL_HF
gboolean __bt_is_companion_device(const char *addr)
{
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
char *host_device_address = NULL;
host_device_address = vconf_get_str(VCONF_KEY_BT_HOST_BT_MAC_ADDR);
}
if (g_strcmp0(host_device_address, addr) == 0) {
- BT_INFO("addr[%s] is companion device", addr);
+ BT_INFO("Found companion device");
+ free(host_device_address);
return TRUE;
}
+ free(host_device_address);
return FALSE;
#else
/* TODO : Need to add companion device check condition for Phone models */
#endif
static int __bt_is_headset_connected(int type, int req_id,
- const char *address, GArray **out_param1)
+ const char *address)
{
gboolean connected = FALSE;
char connected_address[BT_ADDRESS_STRING_SIZE + 1];
node = g_list_first(g_connected_list);
while (node != NULL) {
connected_device = node->data;
- if ((connected_device->type & type) == type) {
+ if ((connected_device->type & type)) {
g_strlcpy(connected_address, connected_device->device_address,
BT_ADDRESS_STRING_SIZE + 1);
#ifdef TIZEN_SUPPORT_DUAL_HF
return BLUETOOTH_ERROR_NOT_CONNECTED;
#endif
+ /* Convert BD adress from string type */
+ _bt_convert_addr_string_to_type(device_address.addr, connected_address);
+ int value = BLUETOOTH_ERROR_NONE;
+ value = _bt_audio_disconnect(0, connected_device->type & type, &device_address, NULL);
+
/* If already one device is waiting, remove current waiting device and add new */
- if (g_wait_data != NULL) {
- if (g_strcmp0(g_wait_data->address, address) != 0) {
- __bt_remove_device_from_wait_list();
- __bt_free_wait_data();
+ if (value == BLUETOOTH_ERROR_NONE) {
+ if (g_wait_data != NULL) {
+ if (g_strcmp0(g_wait_data->address, address) != 0) {
+ __bt_remove_device_from_wait_list();
+ __bt_free_wait_data();
+ }
+ }
+
+ if (g_wait_data == NULL) {
+ g_wait_data = g_malloc0(sizeof(bt_headset_wait_t));
+ g_wait_data->address = g_strdup(address);
+ g_wait_data->req_id = req_id;
+ g_wait_data->type = type;
+ g_wait_data->ag_flag = FALSE;
+
+ /* Set disconnection type */
+ __bt_set_headset_disconnection_type(connected_address);
}
}
- if (g_wait_data == NULL) {
- g_wait_data = g_malloc0(sizeof(bt_headset_wait_t));
- g_wait_data->address = g_strdup(address);
- g_wait_data->req_id = req_id;
- g_wait_data->type = type;
- g_wait_data->ag_flag = FALSE;
- g_wait_data->out_param1 = out_param1;
+ return value;
+}
+
+static int __bt_is_headset_connecting(int type)
+{
+ bt_connected_headset_data_t *connected_device = NULL;
+
+ /* Check if any other headset is connected */
+ GList *node = NULL;
- /* Set disconnection type */
- __bt_set_headset_disconnection_type(connected_address);
+ node = g_list_first(g_connected_list);
+ while (node != NULL) {
+ connected_device = node->data;
+ if (connected_device->device_state == BT_STATE_CONNECTING)
+ return BLUETOOTH_ERROR_CONNECTION_BUSY;
+ node = g_list_next(node);
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int __bt_is_headset_disconnecting(int type)
+{
+ bt_connected_headset_data_t *connected_device = NULL;
+
+ /* Check if any other headset is connected */
+ GList *node = NULL;
+
+ node = g_list_first(g_connected_list);
+ while (node != NULL) {
+ connected_device = node->data;
+ if (connected_device->device_state == BT_STATE_DISCONNECTING)
+ return BLUETOOTH_ERROR_CONNECTION_BUSY;
+
+ node = g_list_next(node);
}
- /* Convert BD adress from string type */
- _bt_convert_addr_string_to_type(device_address.addr, connected_address);
- _bt_audio_disconnect(0, connected_device->type & type, &device_address, NULL);
return BLUETOOTH_ERROR_NONE;
}
if (connected_device->type & BT_AVRCP)
connected_device->type &= ~(BT_AVRCP);
break;
+ case BT_AUDIO_A2DP_SOURCE:
+ if (connected_device->type & BT_AUDIO_A2DP_SOURCE)
+ connected_device->type &= ~(BT_AUDIO_A2DP_SOURCE);
}
BT_DBG("Connection type = %x\n", connected_device->type);
if (connected_device->type == 0x00) {
g_connected_list = g_list_remove(g_connected_list, connected_device);
g_free(connected_device);
+ } else {
+ connected_device->device_state = BT_STATE_CONNECTED;
}
node = g_list_next(node);
int _bt_audio_connect(int request_id, int type,
bluetooth_device_address_t *device_address,
- GArray **out_param1)
+ GArray *out_param1)
{
int result = BLUETOOTH_ERROR_NONE;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
GDBusProxy *adapter_proxy;
GDBusConnection *g_conn;
int ret;
- char *uuid;
+ char *uuid = NULL;
int value = BLUETOOTH_ERROR_NONE;
bt_audio_function_data_t *func_data;
+ guint hfp_hs_restricted = 0x0; /* set default "allowed" */
+ guint a2dp_restricted = 0x0;
BT_CHECK_PARAMETER(device_address, return);
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_conn = _bt_get_system_gconn();
+ g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
func_data->req_id = request_id;
func_data->type = type;
func_data->pending = BT_PENDING_NONE;
- func_data->out_param = out_param1;
+
+ result = _bt_get_restrict_profile(device_address, RESTRICTED_PROFILE_HFP_HS, &hfp_hs_restricted);
+ if (result != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Can't get hfp_hs restriction info");
+
+ result = _bt_get_restrict_profile(device_address, RESTRICTED_PROFILE_A2DP, &a2dp_restricted);
+ if (result != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Can't get a2dp restriction info");
switch (type) {
case BT_AUDIO_HSP:
uuid = A2DP_SOURCE_UUID;
break;
case BT_AUDIO_ALL:
- if (__bt_device_support_uuid(address, BT_AUDIO_HSP)) {
- uuid = HFP_HS_UUID;
- func_data->pending = BT_PENDING_CONNECT;
- type = BT_AUDIO_HSP;
- } else if (__bt_device_support_uuid(address, BT_AUDIO_A2DP)) {
- uuid = A2DP_SINK_UUID;
- type = BT_AUDIO_A2DP;
- } else {
- BT_ERR("No audio role supported");
- result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
+ if ((hfp_hs_restricted == 0x0) && (a2dp_restricted == 0x0)) { /* in case of both profiles are not restricted */
+ if (__bt_device_support_uuid(address, BT_AUDIO_HSP)) {
+ uuid = HFP_HS_UUID;
+ func_data->pending = BT_PENDING_CONNECT;
+ type = BT_AUDIO_HSP;
+ } else if (__bt_device_support_uuid(address, BT_AUDIO_A2DP)) {
+ uuid = A2DP_SINK_UUID;
+ type = BT_AUDIO_A2DP;
+ } else {
+ BT_ERR("No audio role supported");
+ result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
+ goto fail;
+ }
+ } else if ((hfp_hs_restricted == 0x1) && (a2dp_restricted == 0x1)) { /* in case of both profiles are restricted */
+ BT_ERR("All profiles are restricted");
+ result = BLUETOOTH_ERROR_INTERNAL;
goto fail;
+ } else if (a2dp_restricted == 0x01) { /* in case of a2dp is restricted, only connection for hfp_hs */
+ if (__bt_device_support_uuid(address, BT_AUDIO_HSP)) {
+ uuid = HFP_HS_UUID;
+ type = BT_AUDIO_HSP;
+ } else {
+ BT_ERR("HFP_HS role is not supported");
+ result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
+ goto fail;
+ }
+ } else if (hfp_hs_restricted == 0x01) { /* in case of hfp_hs is restricted, only connection for a2dp */
+ if (__bt_device_support_uuid(address, BT_AUDIO_A2DP)) {
+ uuid = A2DP_SINK_UUID;
+ type = BT_AUDIO_A2DP;
+ } else {
+ BT_ERR("A2DP role is not supported");
+ result = BLUETOOTH_ERROR_SERVICE_NOT_FOUND;
+ goto fail;
+ }
}
break;
+ case BT_AVRCP_TARGET:
+ uuid = AVRCP_REMOTE_UUID;
+ break;
default:
BT_ERR("Unknown role");
result = BLUETOOTH_ERROR_INTERNAL;
}
BT_INFO("Connecting to service %s", uuid);
- value = __bt_is_headset_connected(type, request_id, address, out_param1);
+ value = __bt_is_headset_connected(type, request_id, address);
if (value == BLUETOOTH_ERROR_ALREADY_CONNECT) {
return BLUETOOTH_ERROR_ALREADY_CONNECT;
} else if (value == BLUETOOTH_ERROR_NOT_CONNECTED) {
+ value = __bt_is_headset_connecting(type);
+ if (value != BLUETOOTH_ERROR_NONE) {
+ result = BLUETOOTH_ERROR_IN_PROGRESS;
+ goto fail;
+ }
_bt_headset_set_local_connection(TRUE);
ret = _bt_connect_profile(address, uuid,
__bt_audio_request_cb, func_data);
/* Add data to the connected list */
_bt_add_headset_to_list(type, BT_STATE_CONNECTING, address);
+ } else if (value == BLUETOOTH_ERROR_IN_PROGRESS) {
+ return BLUETOOTH_ERROR_IN_PROGRESS;
}
+ if (out_param1)
+ g_array_free(out_param1, TRUE);
+
return BLUETOOTH_ERROR_NONE;
fail:
- g_array_append_vals(*out_param1, address,
- BT_ADDRESS_STR_LEN);
+ if (out_param1 != NULL)
+ g_array_append_vals(out_param1, address,
+ BT_ADDRESS_STR_LEN);
return result;
}
int _bt_audio_disconnect(int request_id, int type,
bluetooth_device_address_t *device_address,
- GArray **out_param1)
+ GArray *out_param1)
{
int result = BLUETOOTH_ERROR_NONE;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
GList *node;
int ret;
char *uuid;
+ int value = BLUETOOTH_ERROR_NONE;
BT_CHECK_PARAMETER(device_address, return);
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_conn = _bt_get_system_gconn();
+ g_conn = _bt_gdbus_get_system_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
func_data = g_malloc0(sizeof(bt_audio_function_data_t));
- retv_if(func_data == NULL, BLUETOOTH_ERROR_INTERNAL);
-
+ /* Fix : NULL_RETURNS */
+ if (func_data == NULL) {
+ BT_ERR("Memory allocation error");
+ result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+ goto fail;
+ }
func_data->address = g_strdup(address);
func_data->req_id = request_id;
func_data->pending = BT_PENDING_NONE;
- func_data->out_param = out_param1;
func_data->type = type;
switch (type) {
uuid = A2DP_SOURCE_UUID;
break;
case BT_AUDIO_ALL:
- if (_bt_is_service_connected(address, BT_AUDIO_HSP)) {
- uuid = HFP_HS_UUID;
- func_data->pending = BT_PENDING_DISCONNECT;
- } else if (_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
+ if (_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
uuid = A2DP_SINK_UUID;
+ func_data->pending = BT_PENDING_DISCONNECT;
+ } else if (_bt_is_service_connected(address, BT_AUDIO_HSP)) {
+ uuid = HFP_HS_UUID;
} else {
BT_ERR("No audio service connected");
result = BLUETOOTH_ERROR_NOT_CONNECTED;
goto fail;
}
break;
+ case BT_AVRCP_TARGET:
+ uuid = AVRCP_REMOTE_UUID;
+ break;
default:
BT_ERR("Unknown role");
result = BLUETOOTH_ERROR_INTERNAL;
goto fail;
}
-
+ value = __bt_is_headset_disconnecting(type);
+ if (value != BLUETOOTH_ERROR_NONE) {
+ BT_INFO("Disconnect in progress");
+ result = BLUETOOTH_ERROR_IN_PROGRESS;
+ goto fail;
+ }
BT_INFO("Disconnecting service %s", uuid);
ret = _bt_disconnect_profile(address, uuid,
__bt_audio_request_cb, func_data);
}
_bt_add_headset_to_list(type, BT_STATE_DISCONNECTING, address);
+ if (out_param1)
+ g_array_free(out_param1, TRUE);
+
return BLUETOOTH_ERROR_NONE;
fail:
if (out_param1 != NULL)
- g_array_append_vals(*out_param1, address,
+ g_array_append_vals(out_param1, address,
BT_ADDRESS_STR_LEN);
return result;
int _bt_hf_connect(int request_id,
bluetooth_device_address_t *device_address,
- GArray **out_param1)
+ GArray *out_param1)
{
int result = BLUETOOTH_ERROR_NONE;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bt_function_data_t *func_data;
GDBusProxy *adapter_proxy;
GDBusConnection *g_conn;
+ gboolean connected = FALSE;
int ret;
char *uuid;
goto fail;
}
- g_conn = _bt_get_system_gconn();
+ g_conn = _bt_gdbus_get_system_gconn();
if (g_conn == NULL) {
result = BLUETOOTH_ERROR_INTERNAL;
goto fail;
}
+ /* Check if HF is connected or not */
+ result = _bt_is_device_connected(device_address, BT_PROFILE_CONN_HFG, &connected);
+ if (connected == TRUE) {
+ BT_ERR("HF is already connected");
+ result = BLUETOOTH_ERROR_ALREADY_CONNECT;
+ goto fail;
+ }
+
func_data = g_malloc0(sizeof(bt_function_data_t));
/* Fix : NULL_RETURNS */
if (func_data == NULL) {
return ret;
}
g_free(uuid);
+ if (out_param1)
+ g_array_free(out_param1, TRUE);
+
return BLUETOOTH_ERROR_NONE;
fail:
if (out_param1 != NULL)
- g_array_append_vals(*out_param1, address,
+ g_array_append_vals(out_param1, address,
BT_ADDRESS_STR_LEN);
return result;
int _bt_hf_disconnect(int request_id,
bluetooth_device_address_t *device_address,
- GArray **out_param1)
+ GArray *out_param1)
{
int result = BLUETOOTH_ERROR_NONE;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
goto fail;
}
- g_conn = _bt_get_system_gconn();
+ g_conn = _bt_gdbus_get_system_gconn();
if (g_conn == NULL) {
result = BLUETOOTH_ERROR_INTERNAL;
goto fail;
return ret;
}
g_free(uuid);
+ if (out_param1)
+ g_array_free(out_param1, TRUE);
+
return BLUETOOTH_ERROR_NONE;
fail:
if (out_param1 != NULL)
- g_array_append_vals(*out_param1, address,
+ g_array_append_vals(out_param1, address,
BT_ADDRESS_STR_LEN);
return result;
BT_DBG("+\n");
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
BT_DBG("Content Protection status = [%d]", status);
BT_DBG("Emit Signal done = [ProtectionRequired]");
return BLUETOOTH_ERROR_NONE;
}
+
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+static void __bt_auto_connect_request_cb(GDBusProxy *proxy, GAsyncResult *res,
+ gpointer user_data)
+{
+ GError *err = NULL;
+ GVariant *reply = NULL;
+
+ reply = g_dbus_proxy_call_finish(proxy, res, &err);
+ g_object_unref(proxy);
+ g_variant_unref(reply);
+
+ BT_DBG("+");
+ if (err != NULL) {
+ g_dbus_error_strip_remote_error(err);
+ BT_INFO("Auto_connect_request Dbus Call Error: %s", err->message);
+
+ if (strcmp("Host is down", err->message)) {
+ BT_INFO("Fail reason is not 'Host Down'. Terminate auto connect");
+ _bt_audio_stop_auto_connect();
+ vconf_set_str(BT_LAST_CONNECTED_DEVICE, "");
+ }
+ }
+ g_clear_error(&err);
+}
+
+
+// It is the function that retry to create alarm.
+// Sometimes alarm mgr service is created later than bluetooth-frwk service in booting time.
+// So, in this case, we have to retry alarmmgr_add_alarm.
+static gboolean __bt_audio_alarm_retry_cb(gpointer data)
+{
+ int result;
+ alarm_id_t alarm_id;
+
+ BT_DBG("__bt_audio_alarm_retry_cb called.");
+ result = _bt_service_set_alarm(BT_AUTO_CONNECT_TIMEOUT_AFTER_LINKLOSS,
+ __bt_auto_connect_alarm_cb, NULL, &alarm_id);
+
+ if (result != BLUETOOTH_ERROR_NONE)
+ return TRUE;
+ else
+ auto_connect_timer.alarm_id = alarm_id;
+
+ return FALSE;
+}
+
+static int __bt_auto_connect_alarm_cb(alarm_id_t alarm_id, void* user_param)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ char *address = NULL;
+ alarm_id_t new_alarm_id;
+
+ BT_INFO("alram id = [%d] , retry_count [%d] ",
+ alarm_id, auto_connect_timer.retry_count);
+
+ if (alarm_id != auto_connect_timer.alarm_id)
+ return 0;
+
+ address = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
+
+ if (address == NULL) {
+ BT_ERR("Address vconf is null");
+ auto_connect_timer.alarm_id = 0;
+ return 0;
+ }
+
+ BT_DBG("ADDRESS [%s]", address);
+
+ result = _bt_connect_profile(address, A2DP_SOURCE_UUID,
+ __bt_auto_connect_request_cb, NULL);
+
+ auto_connect_timer.retry_count--;
+
+ BT_DBG("result [%d]", result);
+
+ if (auto_connect_timer.retry_count <= 0) {
+ BT_INFO("Stopping Auto connect retry");
+ auto_connect_timer.alarm_id = 0;
+ } else {
+ result = _bt_service_set_alarm(BT_AUTO_CONNECT_TIMEOUT_AFTER_LINKLOSS,
+ __bt_auto_connect_alarm_cb, NULL, &new_alarm_id);
+ if (result == BLUETOOTH_ERROR_NONE)
+ auto_connect_timer.alarm_id = new_alarm_id;
+ }
+
+ free(address);
+ return 0;
+}
+
+static void __bt_auto_connect_alarm_remove()
+{
+ BT_DBG("");
+ if (auto_connect_timer.alarm_id > 0) {
+ _bt_service_remove_alarm(auto_connect_timer.alarm_id);
+ auto_connect_timer.alarm_id = 0;
+ }
+ auto_connect_timer.retry_count = 0;
+}
+
+int _bt_audio_start_auto_connect(gboolean linkloss_flag)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ char *address = NULL;
+ alarm_id_t alarm_id = 0;
+
+ BT_DBG("");
+
+ address = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
+
+ if (address == NULL) {
+ BT_ERR("No target device");
+ return 0;
+ }
+
+ __bt_auto_connect_alarm_remove();
+
+ auto_connect_timer.retry_count = BT_AUTO_CONNECT_TIMEOUT_RETRY_TIME /
+ BT_AUTO_CONNECT_TIMEOUT_AFTER_LINKLOSS;
+
+ if (linkloss_flag) {
+ BT_INFO("Start auto connection after linkloss");
+ result = _bt_service_set_alarm(BT_AUTO_CONNECT_TIMEOUT_AFTER_LINKLOSS,
+ __bt_auto_connect_alarm_cb, NULL, &alarm_id);
+ if (result != BLUETOOTH_ERROR_NONE)
+ g_timeout_add(500, (GSourceFunc)__bt_audio_alarm_retry_cb, NULL);
+ else
+ auto_connect_timer.alarm_id = alarm_id;
+
+ } else {
+ BT_INFO("Start auto connection after BT activated");
+ result = _bt_service_set_alarm(BT_AUTO_CONNECT_TIMEOUT_AFTER_BT_ACTIVATED,
+ __bt_auto_connect_alarm_cb, NULL, &alarm_id);
+ if (result == BLUETOOTH_ERROR_NONE)
+ auto_connect_timer.alarm_id = alarm_id;
+ }
+
+ free(address);
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_audio_stop_auto_connect(void)
+{
+ BT_DBG("");
+ __bt_auto_connect_alarm_remove();
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_audio_set_auto_connect_device_addr(const char *address)
+{
+ if (address == NULL) {
+ BT_ERR("address is null");
+ return;
+ }
+
+ BT_INFO("Last connected device is [%s]", address);
+ vconf_set_str(BT_LAST_CONNECTED_DEVICE, address);
+}
+#endif /*TIZEN_BT_A2DP_SINK_AUTO_CONNECT */
BT_DBG("+");
- retv_if(avrcp_control_path != NULL, avrcp_control_path);
+ if (avrcp_control_path != NULL)
+ return avrcp_control_path;
retv_if(!_bt_is_headset_type_connected(BT_AVRCP,
connected_address), NULL);
retv_if(name == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = _bt_get_system_conn();
+ BT_INFO("Command [%s]", name);
+
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
control_path = __bt_get_control_device_path();
case PREVIOUS:
ret = __bt_media_send_control_msg("Previous");
break;
- case FAST_FORWARD:
- ret = __bt_media_send_control_msg("FastForward");
+ case PRESS_FAST_FORWARD:
+ ret = __bt_media_send_control_msg("PressFastForward");
+ break;
+ case RELEASE_FAST_FORWARD:
+ ret = __bt_media_send_control_msg("ReleaseFastForward");
+ break;
+ case PRESS_REWIND:
+ ret = __bt_media_send_control_msg("PressRewind");
break;
- case REWIND:
- ret = __bt_media_send_control_msg("Rewind");
+ case RELEASE_REWIND:
+ ret = __bt_media_send_control_msg("ReleaseRewind");
break;
default:
BT_DBG("Invalid Type\n");
retv_if(control_path == NULL, NULL);
BT_DBG("control_path = %s", control_path);
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, NULL);
proxy = g_dbus_proxy_new_sync(conn,
int ret = BLUETOOTH_ERROR_NONE;
GError *err = NULL;
GVariant *reply = NULL;
+ GVariant *temp = NULL;
BT_CHECK_PARAMETER(value, return);
retv_if(proxy == NULL, BLUETOOTH_ERROR_NOT_CONNECTED);
reply = g_dbus_proxy_call_sync(proxy,
- "Get", g_variant_new("ss", BT_PLAYER_CONTROL_INTERFACE, __bt_media_type_to_str(type)),
+ "Get", g_variant_new("(ss)", BT_PLAYER_CONTROL_INTERFACE, __bt_media_type_to_str(type)),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
g_object_unref(proxy);
case SHUFFLE:
case SCAN:
case STATUS:
- name = (char *)g_variant_get_string(reply, NULL);
- *value = __bt_media_attrval_to_val(type, name);
- BT_DBG("Type[%s] and Value[%s]", __bt_media_type_to_str(type), name);
+ name = (char *)g_variant_get_data(reply);
+ if (name)
+ *value = __bt_media_attrval_to_val(type, name);
+ BT_INFO("Type[%s] and Value[%s]", __bt_media_type_to_str(type), name);
break;
case POSITION:
- *value = g_variant_get_uint32(reply);
+ g_variant_get(reply, "(v)", &temp);
+ *value = g_variant_get_uint32(temp);
+ g_variant_unref(temp);
+ BT_INFO("Type[%s] and Value[%d]", __bt_media_type_to_str(type), *value);
break;
default:
- BT_DBG("Invalid Type\n");
+ BT_ERR("Invalid Type [%d]", type);
ret = BLUETOOTH_ERROR_INTERNAL;
}
}
switch (type) {
case EQUALIZER:
param = g_variant_new("s", equalizer_status[value].property);
- BT_DBG("equalizer_status %s", equalizer_status[value].property);
+ BT_INFO("equalizer_status %s", equalizer_status[value].property);
break;
case REPEAT:
param = g_variant_new("s", repeat_status[value].property);
- BT_DBG("repeat_status %s", repeat_status[value].property);
+ BT_INFO("repeat_status %s", repeat_status[value].property);
break;
case SHUFFLE:
param = g_variant_new("s", shuffle_settings[value].property);
- BT_DBG("shuffle_settings %s", shuffle_settings[value].property);
+ BT_INFO("shuffle_settings %s", shuffle_settings[value].property);
break;
case SCAN:
param = g_variant_new("s", scan_status[value].property);
- BT_DBG("scan_status %s", scan_status[value].property);
+ BT_INFO("scan_status %s", scan_status[value].property);
break;
default:
BT_ERR("Invalid property type: %d", type);
retv_if(proxy == NULL, BLUETOOTH_ERROR_NOT_CONNECTED);
reply = g_dbus_proxy_call_sync(proxy,
- "Set", g_variant_new("ssv", BT_PLAYER_CONTROL_INTERFACE, __bt_media_type_to_str(type), param),
+ "Set", g_variant_new("(ssv)", BT_PLAYER_CONTROL_INTERFACE, __bt_media_type_to_str(type), param),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
g_object_unref(proxy);
if (strcasecmp(key, "Title") == 0) {
value_string = (char *)g_variant_get_string(value, NULL);
BT_DBG("Value : %s ", value_string);
- metadata->title = value_string;
+ metadata->title = g_strdup(value_string);
} else if (strcasecmp(key, "Artist") == 0) {
value_string = (char *)g_variant_get_string(value, NULL);
BT_DBG("Value : %s ", value_string);
- metadata->artist = value_string;
+ metadata->artist = g_strdup(value_string);
} else if (strcasecmp(key, "Album") == 0) {
value_string = (char *)g_variant_get_string(value, NULL);
BT_DBG("Value : %s ", value_string);
- metadata->album = value_string;
+ metadata->album = g_strdup(value_string);
} else if (strcasecmp(key, "Genre") == 0) {
value_string = (char *)g_variant_get_string(value, NULL);
BT_DBG("Value : %s ", value_string);
- metadata->genre = value_string;
+ metadata->genre = g_strdup(value_string);
} else if (strcasecmp(key, "Duration") == 0) {
value_uint = g_variant_get_uint32(value);
metadata->duration = value_uint;
retv_if(metadata == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
control_path = __bt_get_control_device_path();
(strcasecmp(property, "Scan") == 0) ||
(strcasecmp(property, "Status") == 0)) {
const char *valstr;
- unsigned int type, val;
+ unsigned int type, val = 0;
valstr = g_variant_get_string(value, NULL);
BT_DBG("Value : %s ", valstr);
type = __bt_media_attr_to_type(property);
- val = __bt_media_attrval_to_val(type, valstr);
+ if (valstr)
+ val = __bt_media_attrval_to_val(type, valstr);
/* Send event to application */
param = g_variant_new("(u)", val);
memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
ret = __bt_avrcp_control_parse_properties(
- &metadata, reply);
+ &metadata, value);
if (BLUETOOTH_ERROR_NONE != ret) {
/* Free key and value because of break unless free not required */
free((char *)property);
g_variant_unref(value);
+ g_free((char *)metadata.title);
+ g_free((char *)metadata.artist);
+ g_free((char *)metadata.album);
+ g_free((char *)metadata.genre);
break;
}
#include <glib.h>
#include <dlog.h>
#include <string.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
#include <dbus/dbus.h>
#include "bluetooth-api.h"
{ STATUS_INVALID, "" }
};
-GDBusConnection *bt_gdbus_conn = NULL;
static guint avrcp_reg_id = 0;
-static GDBusProxy *service_gproxy = NULL;
/* Introspection data exposed from bt-service */
static const gchar bt_avrcp_bluez_introspection_xml[] =
return node_info;
}
-static GDBusProxy *__bt_avrcp_gdbus_init_service_proxy(void)
-{
- BT_DBG("+");
- GDBusProxy *proxy;
- GError *err = NULL;
- char *adapter_path;
-
- if (bt_gdbus_conn == NULL)
- bt_gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
-
- if (!bt_gdbus_conn) {
- if (err) {
- BT_ERR("Unable to connect to gdbus: %s", err->message);
- g_clear_error(&err);
- }
- return NULL;
- }
-
- adapter_path = _bt_get_adapter_path();
- retv_if(adapter_path == NULL, NULL);
-
- proxy = g_dbus_proxy_new_sync(bt_gdbus_conn,
- G_DBUS_PROXY_FLAGS_NONE, NULL,
- BT_BLUEZ_NAME, adapter_path,
- BT_MEDIA_INTERFACE, NULL, &err);
- g_free(adapter_path);
-
- if (!proxy) {
- BT_ERR("Unable to create proxy");
- if (err) {
- BT_ERR("Error: %s", err->message);
- g_clear_error(&err);
- }
- return NULL;
- }
-
- BT_DBG("-");;
- return proxy;
-}
-
-static GDBusProxy *__bt_avrcp_gdbus_get_service_proxy(void)
-{
- return (service_gproxy) ? service_gproxy :
- __bt_avrcp_gdbus_init_service_proxy();
-}
-
int _bt_register_media_player(void)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
gchar *adapter_path;
gboolean shuffle_status;
gchar *path;
- GDBusConnection *conn;
GDBusNodeInfo *node_info;
GDBusProxy *proxy;
GVariantBuilder *builder;
player_settings.position = 0;
shuffle_status = FALSE;
- conn = _bt_get_system_gconn();
- retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- bt_gdbus_conn = conn;
+ g_conn = _bt_gdbus_get_system_gconn();
+ retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
node_info = __bt_avrcp_create_method_node_info(
bt_avrcp_bluez_introspection_xml);
if (node_info == NULL)
return BLUETOOTH_ERROR_INTERNAL;
- avrcp_reg_id = g_dbus_connection_register_object(bt_gdbus_conn,
+ avrcp_reg_id = g_dbus_connection_register_object(g_conn,
BT_MEDIA_OBJECT_PATH,
node_info->interfaces[0],
&method_table,
adapter_path = _bt_get_adapter_path();
retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
- proxy = g_dbus_proxy_new_sync(conn,
+ proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
BT_BLUEZ_NAME, adapter_path,
BT_MEDIA_INTERFACE, NULL, &error);
static void __bt_avrcp_unregister_object_path(void)
{
+ GDBusConnection *g_conn;
+
+ g_conn = _bt_gdbus_get_system_gconn();
+ ret_if(g_conn == NULL);
+
if (avrcp_reg_id > 0) {
- g_dbus_connection_unregister_object(bt_gdbus_conn,
+ g_dbus_connection_unregister_object(g_conn,
avrcp_reg_id);
avrcp_reg_id = 0;
}
int _bt_unregister_media_player(void)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GDBusProxy *proxy;
+ gchar *adapter_path;
GVariant *ret;
GError *error = NULL;
- GDBusConnection *conn;
gchar *path;
+ int result = BLUETOOTH_ERROR_NONE;
- conn = bt_gdbus_conn;
- retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ adapter_path = _bt_get_adapter_path();
+ if (adapter_path == NULL) {
+ result = BLUETOOTH_ERROR_INTERNAL;
+ goto FAIL;
+ }
- proxy = __bt_avrcp_gdbus_get_service_proxy();
- if (proxy == NULL)
- return BLUETOOTH_ERROR_INTERNAL;
+ g_conn = _bt_gdbus_get_system_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("g_conn is NULL");
+ g_free(adapter_path);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ goto FAIL;
+ }
+
+ proxy = g_dbus_proxy_new_sync(g_conn,
+ G_DBUS_PROXY_FLAGS_NONE, NULL,
+ BT_BLUEZ_NAME, adapter_path,
+ BT_MEDIA_INTERFACE, NULL, &error);
+ g_free(adapter_path);
+
+ if (proxy == NULL) {
+ BT_ERR("Unable to create proxy");
+ if (error) {
+ BT_ERR("Error: %s", error->message);
+ g_clear_error(&error);
+ }
+ result = BLUETOOTH_ERROR_INTERNAL;
+ goto FAIL;
+ }
path = g_strdup(BT_MEDIA_OBJECT_PATH);
BT_DBG("path is [%s]", path);
G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &error);
g_free(path);
+ g_object_unref(proxy);
if (ret == NULL) {
BT_ERR("UnregisterPlayer failed");
error->code, error->message);
g_clear_error(&error);
}
- return BLUETOOTH_ERROR_INTERNAL;
+ result = BLUETOOTH_ERROR_INTERNAL;
}
+ g_variant_unref(ret);
+FAIL:
__bt_avrcp_unregister_object_path();
- g_variant_unref(ret);
- g_object_unref(bt_gdbus_conn);
- bt_gdbus_conn = NULL;
-
BT_DBG("-");
- return BLUETOOTH_ERROR_NONE;
+ return result;
}
int _bt_avrcp_set_track_info(media_metadata_attributes_t *meta_data)
{
BT_DBG("+");
char *interface = BT_MEDIA_PLAYER_INTERFACE;
- GDBusConnection *conn;
+ GDBusConnection *g_conn;
GError *error = NULL;
GVariantBuilder *builder = NULL;
GVariantBuilder *inner_builder = NULL;
retv_if(meta_data == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = bt_gdbus_conn;
- retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ g_conn = _bt_gdbus_get_system_gconn();;
+ retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
inner_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
"xesam:trackNumber", g_variant_new_int32(meta_data->number));
g_variant_builder_add(inner_builder, "{sv}",
- "mpris:lenght", g_variant_new_int64(meta_data->duration));
+ "mpris:length", g_variant_new_int64(meta_data->duration));
g_variant_builder_add(builder, "{sv}",
"Metadata", g_variant_new("a{sv}", inner_builder));
- ret = g_dbus_connection_emit_signal(conn, NULL, BT_MEDIA_OBJECT_PATH,
+ ret = g_dbus_connection_emit_signal(g_conn, NULL, BT_MEDIA_OBJECT_PATH,
DBUS_INTERFACE_PROPERTIES,
"PropertiesChanged",
g_variant_new("(sa{sv})",
int _bt_avrcp_set_interal_property(int type, media_player_settings_t *properties)
{
BT_DBG("+");
- GDBusConnection *conn;
+ GDBusConnection *g_conn;
int value;
media_metadata_attributes_t meta_data;
gboolean shuffle;
GVariantBuilder *builder = NULL;
GVariant *children[1];
- conn = bt_gdbus_conn;
- retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ g_conn = _bt_gdbus_get_system_gconn();;
+ retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
switch (type) {
case REPEAT:
value = properties->repeat;
- if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
+ if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
BT_MEDIA_PLAYER_INTERFACE, "LoopStatus",
g_variant_new_string(loopstatus_settings[value].property))) {
BT_ERR("Error sending the PropertyChanged signal \n");
else
shuffle = TRUE;
- if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
+ if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
BT_MEDIA_PLAYER_INTERFACE, "Shuffle",
g_variant_new_boolean(shuffle))) {
BT_ERR("Error sending the PropertyChanged signal \n");
break;
case STATUS:
value = properties->status;
- if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
+ if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
BT_MEDIA_PLAYER_INTERFACE, "PlaybackStatus",
g_variant_new_string(player_status[value].property))) {
BT_ERR("Error sending the PropertyChanged signal \n");
break;
case POSITION:
value = properties->position;
- if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
+ if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
BT_MEDIA_PLAYER_INTERFACE, "Position",
g_variant_new_uint32(value))) {
BT_ERR("Error sending the PropertyChanged signal \n");
"xesam:trackNumber", g_variant_new_int32(meta_data.number));
g_variant_builder_add(builder, "{sv}",
- "mpris:lenght", g_variant_new_int64(meta_data.duration));
+ "mpris:length", g_variant_new_int64(meta_data.duration));
- if (!__bt_media_emit_property_changed(conn, BT_MEDIA_OBJECT_PATH,
+ if (!__bt_media_emit_property_changed(g_conn, BT_MEDIA_OBJECT_PATH,
BT_MEDIA_PLAYER_INTERFACE, "Metadata",
g_variant_new("a{sv}", builder))) {
BT_ERR("Error sending the PropertyChanged signal \n");
static GDBusProxy *adapter_properties_proxy;
-static GDBusConnection *system_gconn = NULL;
-
GDBusConnection *_bt_gdbus_init_system_gconn(void)
{
GError *error = NULL;
dbus_threads_init_default();
- if (system_gconn != NULL)
- return system_gconn;
+ if (system_conn != NULL)
+ return system_conn;
- system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
- if (!system_gconn) {
+ if (!system_conn) {
BT_ERR("Unable to connect to dbus: %s", error->message);
g_clear_error(&error);
}
- return system_gconn;
+ return system_conn;
}
GDBusConnection *_bt_gdbus_get_system_gconn(void)
GDBusConnection *local_system_gconn = NULL;
GError *error = NULL;
- if (system_gconn == NULL) {
- system_gconn = _bt_gdbus_init_system_gconn();
- } else if (g_dbus_connection_is_closed(system_gconn)) {
-
+ if (system_conn == NULL) {
+ system_conn = _bt_gdbus_init_system_gconn();
+ } else if (g_dbus_connection_is_closed(system_conn)) {
local_system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (!local_system_gconn) {
g_clear_error(&error);
}
- system_gconn = local_system_gconn;
+ system_conn = local_system_gconn;
+ }
+
+ return system_conn;
+}
+
+GDBusConnection *_bt_gdbus_init_session_gconn(void)
+{
+ GError *error = NULL;
+
+ if (!g_thread_supported())
+ g_thread_init(NULL);
+
+ dbus_threads_init_default();
+
+ if (session_conn != NULL)
+ return session_conn;
+
+ session_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+
+ if (!session_conn) {
+ BT_ERR("Unable to connect to dbus: %s", error->message);
+ g_clear_error(&error);
+ }
+
+ return session_conn;
+}
+
+GDBusConnection *_bt_gdbus_get_session_gconn(void)
+{
+ GDBusConnection *local_session_gconn = NULL;
+ GError *error = NULL;
+
+ if (session_conn == NULL) {
+ session_conn = _bt_gdbus_init_session_gconn();
+ } else if (g_dbus_connection_is_closed(session_conn)) {
+ local_session_gconn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+
+ if (!local_session_gconn) {
+ BT_ERR("Unable to connect to dbus: %s", error->message);
+ g_clear_error(&error);
+ }
+
+ session_conn = local_session_gconn;
}
- return system_gconn;
+ return session_conn;
}
static GDBusProxy *__bt_init_manager_proxy(void)
{
+ GDBusConnection *g_conn;
GDBusProxy *proxy;
- if (system_conn == NULL) {
- system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
- retv_if(system_conn == NULL, NULL);
- }
+ dbus_threads_init_default();
- proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
+ g_conn = _bt_gdbus_get_system_gconn();
+ retv_if(g_conn == NULL, NULL);
+
+ proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_BLUEZ_NAME,
BT_MANAGER_PATH, BT_MANAGER_INTERFACE, NULL, NULL);
- retv_if(proxy == NULL, NULL);
+ if (!proxy) {
+ BT_ERR("Unable to get proxy");
+ return NULL;
+ }
manager_proxy = proxy;
static GDBusProxy *__bt_init_adapter_proxy(void)
{
+ GDBusConnection *g_conn;
GDBusProxy *manager_proxy;
GDBusProxy *proxy;
char *adapter_path = NULL;
- if (system_conn == NULL) {
- system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
- retv_if(system_conn == NULL, NULL);
- }
+ dbus_threads_init_default();
+
+ g_conn = _bt_gdbus_get_system_gconn();
+ retv_if(g_conn == NULL, NULL);
manager_proxy = _bt_get_manager_proxy();
retv_if(manager_proxy == NULL, NULL);
adapter_path = _bt_get_adapter_path();
retv_if(adapter_path == NULL, NULL);
- proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
+ proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_BLUEZ_NAME,
adapter_path, BT_ADAPTER_INTERFACE, NULL, NULL);
static GDBusProxy *__bt_init_adapter_properties_proxy(void)
{
+ GDBusConnection *g_conn;
GDBusProxy *manager_proxy;
GDBusProxy *proxy;
char *adapter_path = NULL;
- if (system_conn == NULL) {
- system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
- retv_if(system_conn == NULL, NULL);
- }
+ dbus_threads_init_default();
+
+ g_conn = _bt_gdbus_get_system_gconn();
+ retv_if(g_conn == NULL, NULL);
manager_proxy = _bt_get_manager_proxy();
retv_if(manager_proxy == NULL, NULL);
adapter_path = _bt_get_adapter_path();
retv_if(adapter_path == NULL, NULL);
- proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
+ proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_BLUEZ_NAME,
adapter_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
return proxy;
}
-GDBusConnection *__bt_init_system_gconn(void)
-{
- if (system_conn == NULL)
- system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
-
- return system_conn;
-}
-
-GDBusConnection *__bt_init_session_conn(void)
-{
- if (session_conn == NULL)
- session_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
-
- return session_conn;
-}
-
-GDBusConnection *_bt_get_session_gconn(void)
-{
- return (session_conn) ? session_conn : __bt_init_session_conn();
-}
-
-GDBusConnection *_bt_get_system_gconn(void)
-{
- return (system_conn) ? system_conn : __bt_init_system_gconn();
-}
-
-GDBusConnection *_bt_get_system_conn(void)
-{
- GDBusConnection *g_conn;
-
- if (system_conn == NULL) {
- g_conn = __bt_init_system_gconn();
- } else {
- g_conn = system_conn;
- }
-
- retv_if(g_conn == NULL, NULL);
-
- return g_conn;
-}
-
GDBusProxy *_bt_get_manager_proxy(void)
{
if (manager_proxy) {
GVariantIter *iter = NULL;
char *adapter_path = NULL;
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, NULL);
manager_proxy = _bt_get_manager_proxy();
dev_addr += 4;
g_strlcpy(address, dev_addr, sizeof(address));
- while ((pos = strchr(address, '_')) != NULL) {
+ while ((pos = strchr(address, '_')) != NULL)
*pos = ':';
- }
g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
}
void _bt_convert_addr_string_to_type(unsigned char *addr,
const char *address)
{
- int i;
- char *ptr = NULL;
+ int i;
+ char *ptr = NULL;
+
+ ret_if(address == NULL);
+ ret_if(addr == NULL);
+
+ for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
+ addr[i] = strtol(address, &ptr, 16);
+ if (ptr[0] != '\0') {
+ if (ptr[0] != ':')
+ return;
+
+ address = ptr + 1;
+ }
+ }
+}
+
+void _bt_convert_addr_string_to_secure_string(char *addr,
+ const char *address)
+{
+ int len;
ret_if(address == NULL);
ret_if(addr == NULL);
- for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
- addr[i] = strtol(address, &ptr, 16);
- if (ptr[0] != '\0') {
- if (ptr[0] != ':')
- return;
+ len = strlen(address);
+ ret_if(len != BT_ADDRESS_STRING_SIZE - 1);
- address = ptr + 1;
- }
- }
+ strncpy(addr, address, len);
+
+ addr[len-1] = 'X';
+ addr[len-2] = 'X';
+
+ return;
}
void _bt_convert_addr_type_to_string(char *address,
if (arg < 0)
return -errno;
- if (arg & O_NONBLOCK) {
+ if (arg & O_NONBLOCK)
BT_ERR("Already Non-blocking \n");
- }
arg |= O_NONBLOCK;
/* Parse the signature: oa{sa{sv}}} */
while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
NULL)) {
- retv_if(object_path == NULL, NULL);
+ if (!object_path) {
+ BT_ERR("Unable to get object path");
+ return NULL;
+ }
_bt_convert_device_path_to_address(object_path, device_address);
- if (g_strcmp0(address, device_address) == 0) {
+ if (g_strcmp0(address, device_address) == 0)
return g_strdup(object_path);
- }
+
}
+
+ BT_ERR("Unable to get object path");
return NULL;
}
GVariant *result = NULL;
GVariantIter *iter = NULL;
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, NULL);
manager_proxy = _bt_get_manager_proxy();
return strdup(NAP_UUID);
case BT_PROFILE_CONN_HFG:
return strdup(HFP_AG_UUID);
+ case BT_PROFILE_CONN_PBAP:
+ return strdup(PBAP_UUID);
case BT_PROFILE_CONN_GATT:
case BT_PROFILE_CONN_ALL: /* NULL UUID will connect to both the audio profiles*/
default:
return "ALREADY_DEACTIVATED";
case BLUETOOTH_ERROR_NOT_INITIALIZED:
return "NOT_INITIALIZED";
+ case BLUETOOTH_ERROR_AUTHENTICATION_REJECTED:
+ return "AUTHENTICATION REJECTED";
default:
return "UNKNOWN";
}
char * _bt_convert_disc_reason_to_string(int reason)
{
switch (reason) {
- case 1:
+ case (int)BLUETOOTH_ERROR_PAGE_TIMEOUT:
+ return "Page timeout";
+ case (int)BLUETOOTH_ERROR_CONNECTION_TIMEOUT:
return "Link loss";
- case 2:
+ case (int)BLUETOOTH_ERROR_PIN_OR_KEY_MISSING:
+ return "PIN or Key missing";
+ case (int)BLUETOOTH_ERROR_LOCAL_HOST_TERM:
return "Connection terminated by local host";
- case 3:
+ case (int)BLUETOOTH_ERROR_REMOTE_USER_TERM:
+ case (int)BLUETOOTH_ERROR_REMOTE_LOW_RESOURCES:
+ case (int)BLUETOOTH_ERROR_REMOTE_POWER_OFF:
return "Remote user terminated connection";
- case 0:
+ case (int)BLUETOOTH_ERROR_AUTH_FAILURE:
+ return "Authentication Failure";
+ case (int)BLUETOOTH_ERROR_REPEATED_ATTEMPTS:
+ return "Repeated attempts";
+ case (int)BLUETOOTH_ERROR_LMP_RESPONSE_TIMEOUT:
+ return "LMP response timeout";
+ case (int)BLUETOOTH_ERROR_CONNECTION_FAILED_TO_BE_ESTABLISHED:
+ return "Connection failed to be established";
default:
return "Unknown";
}
le_conn, le_disc, edr_conn, edr_disc);
}
-int _bt_eventsystem_set_value(const char *event, const char *key, const char *value)
-{
- int ret;
- bundle *b = NULL;
-
- b = bundle_create();
-
- bundle_add_str(b, key, value);
-
- ret = eventsystem_send_system_event(event, b);
-
- BT_DBG("eventsystem_send_system_event result: %d", ret);
-
- bundle_free(b);
-
- return ret;
-}
-
void _bt_swap_byte_ordering(char *data, int data_len)
{
char temp;
int i, j;
+ int half = data_len / 2;
ret_if(data == NULL);
/* Swap to opposite endian */
- for (i = 0, j = data_len - 1; i < data_len; i++, j--) {
+ for (i = 0, j = data_len - 1; i < half; i++, j--) {
temp = data[i];
data[i] = data[j];
data[j] = temp;
- }
+ }
}
int _bt_byte_arr_cmp(const char *data1, const char *data2, int data_len)
}
return 0;
}
+
+int _bt_eventsystem_set_value(const char *event, const char *key, const char *value)
+{
+ int ret = ES_R_OK;
+/* Send event system event in bt-core process because bt-service's permission is not system in now */
+\r#if 0
+ bundle *b = NULL;
+
+ b = bundle_create();
+
+ bundle_add_str(b, key, value);
+
+ ret = eventsystem_send_system_event(event, b);
+
+ BT_DBG("eventsystem_send_system_event result: %d", ret);
+
+ bundle_free(b);
+#endif
+ return ret;
+}
+
+void __bt_get_auth_info(GVariant *reply, char *auth_info)
+{
+ int cursor;
+ GVariant *tmp_value;
+ char *manufacturer_data = NULL;
+ int manufacturer_data_len;
+ gboolean is_alias_set;
+ GVariantIter *value_iter;
+ guint8 m_value;
+ int i = 0;
+
+ tmp_value = g_variant_lookup_value(reply, "IsAliasSet",
+ G_VARIANT_TYPE_BOOLEAN);
+ if (tmp_value) {
+ is_alias_set = g_variant_get_boolean(tmp_value);
+ g_variant_unref(tmp_value);
+ } else {
+ is_alias_set = FALSE;
+ }
+ if (is_alias_set == FALSE) {
+ tmp_value = g_variant_lookup_value(reply, "ManufacturerDataLen",
+ G_VARIANT_TYPE_UINT16);
+ if (tmp_value) {
+ manufacturer_data_len = g_variant_get_uint16(tmp_value);
+ if (manufacturer_data_len >
+ BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
+ BT_ERR("manufacturer_data_len is too long");
+ manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
+ }
+ g_variant_unref(tmp_value);
+ } else
+ manufacturer_data_len = 0;
+
+ tmp_value = g_variant_lookup_value(reply, "ManufacturerData",
+ G_VARIANT_TYPE_ARRAY);
+ if (tmp_value) {
+ if ((manufacturer_data_len == 0) ||
+ manufacturer_data_len != g_variant_get_size(tmp_value)) {
+ BT_ERR("manufacturer data length doesn't match");
+ manufacturer_data_len = 0;
+ manufacturer_data = NULL;
+ } else {
+ manufacturer_data = g_malloc0(manufacturer_data_len);
+ g_variant_get(tmp_value, "ay", &value_iter);
+ while (g_variant_iter_loop(value_iter, "y", &m_value))
+ manufacturer_data[i++] = m_value;
+ }
+ g_variant_unref(tmp_value);
+ } else {
+ BT_INFO("manufacture data is not a G_VARIANT_TYPE_ARRAY ");
+ manufacturer_data_len = 0;
+ manufacturer_data = NULL;
+ }
+ /*minimum Size of the samsung specific manufacturer data is greater than 30 */
+ if (manufacturer_data_len < 30) {
+ g_free(manufacturer_data);
+ return;
+ }
+ if (manufacturer_data[0] != 0x00 || manufacturer_data[1] != 0x75) {
+ BT_DBG("This is not a samsung specific manufaturer data");
+ g_free(manufacturer_data);
+ return;
+ }
+
+ /* 2 samsung (0x00 0x75) + 1 (control and version) + 1 (service ID) +
+ 1 (discovery version) + 1 (associated service ID)
+ 2 (Proxamity and locality) + 2 (Device type and icon) */
+
+ cursor = 10;
+
+ memcpy(auth_info, &(manufacturer_data[cursor]), 5);
+ }
+ g_free(manufacturer_data);
+}
+
+int _bt_convert_gerror(GError *g_error)
+{
+ int ret = BLUETOOTH_ERROR_INTERNAL;
+ gchar *str;
+
+ if (!g_dbus_error_strip_remote_error(g_error))
+ return ret;
+
+ str = g_error->message;
+
+ if (g_strcmp0(str, "Connection refused") == 0)
+ ret = BLUETOOTH_ERROR_AUTHENTICATION_REJECTED;
+ else if (g_strcmp0(str, "Connection timed out") == 0)
+ ret = BLUETOOTH_ERROR_TIMEOUT;
+ else if (g_strcmp0(str, "In Progress") == 0)
+ ret = BLUETOOTH_ERROR_IN_PROGRESS;
+
+ return ret;
+}
#include <gio/gio.h>
#include <dlog.h>
#include <string.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
+#include <vconf.h>
#include <bundle_internal.h>
+
#include "bluetooth-api.h"
#include "bt-internal-types.h"
#include "bt-service-common.h"
+#include "bt-service-adapter-le.h"
#include "bt-service-event.h"
#include "bt-service-device.h"
-#include "bt-service-adapter-le.h"
#include "bt-service-rfcomm-client.h"
#include "bt-service-util.h"
#include "bt-service-agent.h"
#define BT_LE_CONN_TO_SPLIT 10 /* msec */
#define BT_DEVICE_PIN_CODE_SLOT_MAX 10
-#define BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT 20000 /* msec */
+#define BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT 6000 /* msec */
#define BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL 30 /* msec */
#define BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL 50 /* msec */
#define BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY 0 /* event */
-#define BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL 7.5 /* msec */
-#define BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL 10 /* msec */
+#define BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL 10 /* msec */
+#define BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL 30 /* msec */
#define BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY 0 /* event */
#define BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL 80 /* msec */
#define BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL 100 /* msec */
#define BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY 2 /* event */
+#define PROFILE_SUPPORTED 0x3 /* This corresponds to binary 0b11*/
+
typedef struct {
int req_id;
int result;
GDBusProxy *adapter_proxy;
void *agent;
unsigned short conn_type;
+ gboolean bonding_wo_discovery;
} bt_funcion_data_t;
typedef struct {
char *pin_code;
} bt_pin_code_info_t;
+typedef struct {
+ int req_id;
+ bluetooth_device_address_t bd_addr;
+ gboolean auto_connect;
+} bt_pending_le_conn_info_s;
+
gboolean is_device_creating;
bt_funcion_data_t *bonding_info;
bt_funcion_data_t *searching_info;
-bt_funcion_data_t *le_connection_info;
+bt_funcion_data_t *att_mtu_req_info;
static GSList *pin_info_list = NULL;
+static bt_pending_le_conn_info_s *pending_le_conn_info = NULL;
+static guint pending_le_conn_timer_id = 0;
/* This HID Mouse does not support pairing precedure. need to skip it. */
#define SMB_MOUSE_LAP_ADDR "00:12:A1"
BT_DBG("-");
} */
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_PROFILE_WEARABLE
static gboolean __bt_syspopup_timer_cb(gpointer user_data)
{
int ret;
b = (bundle *)user_data;
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
ret = syspopup_launch("bt-syspopup", b);
-#endif
if (ret < 0) {
BT_ERR("Sorry!! Cannot launch popup return = %d, Retrying...", ret);
} else {
bundle *b = NULL;
GDBusConnection *conn;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL)
return FALSE;
else
bundle_add(b, "error", "error");
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
ret = syspopup_launch("bt-syspopup", b);
-#endif
if (0 > ret) {
BT_ERR("Popup launch failed...retry %d \n", ret);
g_timeout_add(200, (GSourceFunc) __bt_syspopup_timer_cb,
bonding_info->is_autopair = is_autopair;
}
-void _bt_device_path_to_address(const char *device_path,
- char *device_address)
-{
- char address[BT_ADDRESS_STRING_SIZE] = { 0 };
- char *dev_addr;
- char *pos;
-
- ret_if(device_path == NULL);
- ret_if(device_address == NULL);
-
- dev_addr = strstr(device_path, "dev_");
- ret_if(dev_addr == NULL);
-
- dev_addr += 4;
- g_strlcpy(address, dev_addr, sizeof(address));
-
- while ((pos = strchr(address, '_')) != NULL) {
- *pos = ':';
- }
-
- g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
-}
-
void __bt_cancel_search_service_done(void)
{
int result = BLUETOOTH_ERROR_CANCEL_BY_USER;
bt_remote_dev_info_t *_bt_get_remote_device_info(char *address)
{
- bt_remote_dev_info_t *dev_info;
char *object_path = NULL;
+ bt_remote_dev_info_t *dev_info;
+
+ retv_if(address == NULL, NULL);
+
+ object_path = _bt_get_device_object_path(address);
+ retv_if(object_path == NULL, NULL);
+
+ dev_info = _bt_get_remote_device_info_by_object_path(object_path);
+
+ g_free(object_path);
+ return dev_info;
+}
+
+bt_remote_dev_info_t *_bt_get_remote_device_info_by_object_path(
+ const char *object_path)
+{
+ bt_remote_dev_info_t *dev_info;
GDBusProxy *adapter_proxy;
GDBusProxy *device_proxy;
GVariant *value;
GVariant *tmp_value;
gchar *name;
- gchar *manufacturer_data = NULL;
+ gchar * address;
GDBusConnection *conn;
GError *error = NULL;
GVariant *result = NULL;
-
- retv_if(address == NULL, NULL);
+ GVariantIter *value_iter;
+ guint8 m_value;
+ int i = 0;
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, NULL);
-
- object_path = _bt_get_device_object_path(address);
-
retv_if(object_path == NULL, NULL);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL) {
BT_ERR("conn == NULL");
- g_free(object_path);
return NULL;
}
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
- NULL, BT_BLUEZ_NAME,
- object_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
+ NULL, BT_BLUEZ_NAME, object_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
- g_free(object_path);
retv_if(device_proxy == NULL, NULL);
result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
g_variant_unref(tmp_value);
}
+ tmp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_BOOLEAN);
+ if (tmp_value) {
+ dev_info->is_alias_set = g_variant_get_boolean(tmp_value);
+ g_variant_unref(tmp_value);
+ } else {
+ dev_info->is_alias_set = FALSE;
+ }
+ BT_DBG("IsAliasSet: [%s]", dev_info->is_alias_set ? "TRUE" : "FALSE");
+
tmp_value = g_variant_lookup_value(value, "Class", G_VARIANT_TYPE_UINT32);
- dev_info->class = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
- g_variant_unref(tmp_value);
+ if (tmp_value) {
+ dev_info->class = g_variant_get_uint32(tmp_value);
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->class = 0;
- tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BOOLEAN);
- dev_info->connected = tmp_value ? g_variant_get_boolean(tmp_value) : BLUETOOTH_CONNECTED_LINK_NONE;
- g_variant_unref(tmp_value);
+ tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BYTE);
+ if (tmp_value) {
+ dev_info->connected = g_variant_get_byte(tmp_value);
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->connected = BLUETOOTH_CONNECTED_LINK_NONE;
+ BT_DBG("connected link : %d", dev_info->connected);
tmp_value = g_variant_lookup_value(value, "Trusted", G_VARIANT_TYPE_BOOLEAN);
- dev_info->trust = tmp_value ? g_variant_get_boolean(tmp_value) : FALSE;
- g_variant_unref(tmp_value);
+ if (tmp_value) {
+ dev_info->trust = g_variant_get_boolean(tmp_value);
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->trust = FALSE;
tmp_value = g_variant_lookup_value(value, "Paired", G_VARIANT_TYPE_BOOLEAN);
- dev_info->paired = tmp_value ? g_variant_get_boolean(tmp_value) : FALSE;
- g_variant_unref(tmp_value);
-
- BT_DBG("Paired %d", dev_info->paired);
+ if (tmp_value) {
+ dev_info->paired = g_variant_get_boolean(tmp_value);
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->paired = FALSE;
- tmp_value = g_variant_lookup_value(value, "RSSI", G_VARIANT_TYPE_INT32);
- dev_info->rssi = tmp_value ? g_variant_get_int32(tmp_value) : 0;
- g_variant_unref(tmp_value);
+ tmp_value = g_variant_lookup_value(value, "RSSI", G_VARIANT_TYPE_INT16);
+ if (tmp_value) {
+ dev_info->rssi = g_variant_get_int16(tmp_value);
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->rssi = 0;
- tmp_value = g_variant_lookup_value(value, "LastAddrType", G_VARIANT_TYPE_UINT32);
- dev_info->addr_type = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
- g_variant_unref(tmp_value);
+ tmp_value = g_variant_lookup_value(value, "LastAddrType", G_VARIANT_TYPE_BYTE);
+ if (tmp_value) {
+ dev_info->addr_type = g_variant_get_byte(tmp_value);
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->addr_type = 0;
tmp_value = g_variant_lookup_value(value, "UUIDs", G_VARIANT_TYPE_STRING_ARRAY);
- __bt_get_uuids(tmp_value, dev_info);
- g_variant_unref(tmp_value);
-
- tmp_value = g_variant_lookup_value(value, "ManufacturerDataLen", G_VARIANT_TYPE_UINT32);
- dev_info->manufacturer_data_len = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
- if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
- BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
- dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
+ if (tmp_value) {
+ __bt_get_uuids(tmp_value, dev_info);
+ g_variant_unref(tmp_value);
}
- g_variant_unref(tmp_value);
- tmp_value = g_variant_lookup_value(value, "ManufacturerData", G_VARIANT_TYPE_BYTESTRING);
- manufacturer_data = value ? (gchar *)g_variant_get_bytestring(tmp_value) : NULL;
- if (manufacturer_data) {
- if (dev_info->manufacturer_data_len > 0) {
+ tmp_value = g_variant_lookup_value(value, "ManufacturerDataLen", G_VARIANT_TYPE_UINT16);
+ if (tmp_value) {
+ dev_info->manufacturer_data_len = g_variant_get_uint16(tmp_value);
+ if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
+ BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
+ dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
+ }
+ g_variant_unref(tmp_value);
+ } else
+ dev_info->manufacturer_data_len = 0;
+
+ tmp_value = g_variant_lookup_value(value, "ManufacturerData", G_VARIANT_TYPE_ARRAY);
+ if (tmp_value) {
+ if ((dev_info->manufacturer_data_len == 0) ||
+ dev_info->manufacturer_data_len != g_variant_get_size(tmp_value)) {
+ BT_ERR("manufacturer data length doesn't match");
+ dev_info->manufacturer_data_len = 0;
+ dev_info->manufacturer_data = NULL;
+ } else {
dev_info->manufacturer_data = g_malloc0(dev_info->manufacturer_data_len);
- memcpy(dev_info->manufacturer_data, manufacturer_data, dev_info->manufacturer_data_len);
+ g_variant_get(tmp_value, "ay", &value_iter);
+ while (g_variant_iter_loop(value_iter, "y", &m_value))
+ dev_info->manufacturer_data[i++] = m_value;
}
+ g_variant_unref(tmp_value);
+ } else {
+ BT_INFO("manufacture data is not a G_VARIANT_TYPE_ARRAY ");
+ dev_info->manufacturer_data_len = 0;
+ dev_info->manufacturer_data = NULL;
}
+
+ tmp_value = g_variant_lookup_value(value, "Address", G_VARIANT_TYPE_STRING);
+ g_variant_get(tmp_value, "s", &address);
g_variant_unref(tmp_value);
dev_info->address = g_strdup(address);
return FALSE;
}
+static int __bt_cancel_bonding(void)
+{
+ BT_CHECK_PARAMETER(bonding_info, return);
+ BT_CHECK_PARAMETER(bonding_info->addr, return);
+ /* First Cancel the ongoing pairing in bluez otherwise if we send
+ * pair request bluez will send inprogress and we again retry bond so
+ * this cycle continues */
+ GError *err = NULL;
+ g_dbus_proxy_call_sync(bonding_info->device_proxy, "CancelPairing",
+ NULL, G_DBUS_CALL_FLAGS_NONE,
+ 10000, NULL, &err);
+ if (err) {
+ BT_ERR("Cancelling bonding request error msg (%s)", err->message);
+ g_clear_error(&err);
+ return BLUETOOTH_ERROR_PARING_FAILED;
+ }
+ return BLUETOOTH_ERROR_NONE;
+}
+
static int __bt_retry_bond(void)
{
BT_CHECK_PARAMETER(bonding_info, return);
}
-static int __bt_remove_and_bond(char *device_path)
+static int __bt_remove_and_bond(void)
{
GDBusProxy *adapter_proxy;
+ GVariant *result = NULL;
GError *err = NULL;
+ char *device_path = NULL;
BT_CHECK_PARAMETER(bonding_info, return);
BT_CHECK_PARAMETER(bonding_info->addr, return);
- retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
-
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(adapter_proxy, "UnpairDevice",
- g_variant_new("(o)", device_path),
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
- &err);
+ result = g_dbus_proxy_call_sync(adapter_proxy, "FindDevice",
+ g_variant_new("(s)", bonding_info->addr),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ NULL);
+ if (result == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ g_variant_get(result , "(o)", &device_path);
+ g_variant_unref(result);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(adapter_proxy, "UnpairDevice",
+ g_variant_new("(o)", device_path),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &err);
+ g_free(device_path);
if (err != NULL) {
BT_ERR("UnpairDevice Fail: %s", err->message);
g_error_free(err);
BT_ERR("Fail to call reply cancellation");
return ret;
}
-
return __bt_retry_bond();
}
{
int result = BLUETOOTH_ERROR_NONE;
GError *err = NULL;
+ GVariant *reply;
GVariant *out_param1;
request_info_t *req_info;
bluetooth_device_info_t dev_info;
bt_remote_dev_info_t *remote_dev_info;
GVariant *manufacture_data;
GVariant *param;
- const char *device_path;
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
/* Terminate ALL system popup */
syspopup_destroy_all();
-#endif
- g_dbus_proxy_call_finish(proxy, res, &err);
+ reply = g_dbus_proxy_call_finish(proxy, res, &err);
+ if (reply)
+ g_variant_unref(reply);
is_device_creating = FALSE;
goto done;
}
- device_path = g_dbus_proxy_get_object_path(proxy);
-
- BT_DBG("device path: %s", device_path);
-
if (err != NULL) {
g_dbus_error_strip_remote_error(err);
BT_ERR("Error occured in CreateBonding [%s]", err->message);
if (g_strrstr(err->message, "Already Exists")) {
BT_INFO("Existing Bond, remove and retry");
- ret_if(__bt_remove_and_bond((char *)device_path) == BLUETOOTH_ERROR_NONE);
-
- BT_INFO("Fail to retry bonding");
+ ret_if(__bt_remove_and_bond() == BLUETOOTH_ERROR_NONE);
result = BLUETOOTH_ERROR_PARING_FAILED;
} else if (_bt_agent_is_canceled() ||
the procedure is stopped. So 'Cancle' error is not return.
*/
result = BLUETOOTH_ERROR_HOST_DOWN;
- } else if (g_strrstr(err->message, BT_TIMEOUT_MESSAGE)) {
- g_dbus_proxy_call_sync(proxy, "CancelDeviceCreation",
- g_variant_new("(s)", bonding_info->addr),
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
- NULL);
-
+ } else if (g_strrstr(err->message, BT_DBUS_TIMEOUT_MESSAGE)) {
+ BT_INFO("Cancel already running bonding");
+ if (__bt_cancel_bonding() != BLUETOOTH_ERROR_NONE) {
+ BT_INFO("Error while Cancelling bonding");
+ /* we need to unref proxy so continue */
+ }
result = BLUETOOTH_ERROR_INTERNAL;
} else if (g_strrstr(err->message, "Connection Timeout")) {
/* Pairing request timeout */
result == BLUETOOTH_ERROR_AUTHENTICATION_FAILED ||
result == BLUETOOTH_ERROR_TIMEOUT ||
result == BLUETOOTH_ERROR_HOST_DOWN) {
- bonding_info->result = result;
-#ifdef TIZEN_WEARABLE
- __bt_launch_unable_to_pairing_syspopup(result);
+#ifdef TIZEN_PROFILE_WEARABLE
+ int is_sw_running = 0;
+
+ if (vconf_get_int(VCONFKEY_SETUP_WIZARD_STATE, &is_sw_running))
+ BT_ERR("vconf_get_int for setup wizard state failed");
+
+ if (!is_sw_running)
+ __bt_launch_unable_to_pairing_syspopup(result);
+ else
+ BT_ERR("Unable to pair");
#endif
+ bonding_info->result = result;
}
g_object_unref(proxy);
bonding_info->device_proxy = NULL;
- if (result != BLUETOOTH_ERROR_NONE)
+ if (result != BLUETOOTH_ERROR_NONE) {
+ if (bonding_info->bonding_wo_discovery) {
+ GDBusProxy *adapter_proxy;
+ GVariant *ret = NULL;
+ GError *error = NULL;
+ char *device_path;
+
+ BT_ERR("Bond was tried without discovery. Remove it");
+
+ adapter_proxy = _bt_get_adapter_proxy();
+ if (adapter_proxy == NULL) {
+ BT_ERR("Cannot get adapter_proxy");
+ goto dbus_return;
+ }
+
+ device_path = _bt_get_device_object_path(bonding_info->addr);
+ if (device_path == NULL) {
+ BT_ERR("Cannot get device path");
+ goto dbus_return;
+ }
+
+ ret = g_dbus_proxy_call_sync(adapter_proxy,
+ "RemoveDevice",
+ g_variant_new("(o)", device_path),
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL,
+ &error);
+ if (error != NULL) {
+ BT_ERR("RemoveDevice Fail: %s", error->message);
+ g_clear_error(&error);
+ }
+
+ if (ret)
+ g_variant_unref(ret);
+
+ g_free(device_path);
+ }
+
goto dbus_return;
+ }
remote_dev_info = _bt_get_remote_device_info(bonding_info->addr);
- if (remote_dev_info == NULL)
+ if (!remote_dev_info)
goto dbus_return;
GVariant *uuids = NULL;
g_variant_new("(iv)", result, out_param1));
g_variant_unref(out_param1);
-// g_variant_unref(out_param2);
_bt_delete_request_list(req_info->req_id);
done:
char *device_path = NULL;
GDBusProxy *adapter_proxy;
GError *error = NULL;
+ gboolean bonding_wo_discovery = FALSE;
BT_CHECK_PARAMETER(device_address, return);
return BLUETOOTH_ERROR_DEVICE_BUSY;
}
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
} else {
BT_INFO("device_path is created[%s]", device_path);
}
+ bonding_wo_discovery = TRUE;
}
proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
bonding_info->device_proxy = proxy;
bonding_info->conn_type = conn_type;
+ bonding_info->bonding_wo_discovery = bonding_wo_discovery;
is_device_creating = TRUE;
gpointer user_data)
{
GError *err = NULL;
+ GVariant *reply;
GVariant *out_param1;
int result = BLUETOOTH_ERROR_NONE;
bt_funcion_data_t *unbonding_info;
bluetooth_device_info_t dev_info;
request_info_t *req_info;
- g_dbus_proxy_call_finish(proxy, res, &err);
+ reply = g_dbus_proxy_call_finish(proxy, res, &err);
+ if (reply)
+ g_variant_unref(reply);
unbonding_info = user_data;
goto fail;
}
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL) {
BT_ERR("conn is NULL");
result = BLUETOOTH_ERROR_INTERNAL;
BT_MAX_DBUS_TIMEOUT,
NULL,
(GAsyncReadyCallback)__bt_unbond_cb,
- NULL);
+ unbonding_info);
g_free(device_path);
return BLUETOOTH_ERROR_NONE;
gpointer user_data)
{
GError *err = NULL;
+ GVariant *reply;
GVariant *out_param1;
int result = BLUETOOTH_ERROR_NONE;
bluetooth_device_info_t dev_info;
GVariantBuilder *builder = NULL;
int i = 0;
- g_dbus_proxy_call_finish(proxy, res, &err);
+ reply = g_dbus_proxy_call_finish(proxy, res, &err);
+ if (reply)
+ g_variant_unref(reply);
g_object_unref(proxy);
g_dbus_error_strip_remote_error(err);
BT_ERR("Error occured in Proxy call [%s]\n", err->message);
- if (g_strrstr("Operation canceled", err->message)) {
+ if (g_strrstr("Operation canceled", err->message))
result = BLUETOOTH_ERROR_CANCEL_BY_USER;
- } else if (g_strrstr("In Progress", err->message)) {
+ else if (g_strrstr("In Progress", err->message))
result = BLUETOOTH_ERROR_IN_PROGRESS;
- } else if (g_strrstr("Host is down", err->message)) {
+ else if (g_strrstr("Host is down", err->message))
result = BLUETOOTH_ERROR_HOST_DOWN;
- } else {
+ else
result = BLUETOOTH_ERROR_CONNECTION_ERROR;
- }
if (result == BLUETOOTH_ERROR_HOST_DOWN ||
result == BLUETOOTH_ERROR_CONNECTION_ERROR) {
}
remote_dev_info = _bt_get_remote_device_info(searching_info->addr);
- if (remote_dev_info == NULL)
+ if (!remote_dev_info)
goto dbus_return;
event:
_bt_convert_addr_type_to_string(searching_info->addr,
device_address->addr);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
return BLUETOOTH_ERROR_NONE;
fail:
+
g_free(searching_info->addr);
g_free(searching_info);
searching_info = NULL;
int _bt_cancel_search_device(void)
{
+ GVariant *ret = NULL;
GError *err = NULL;
retv_if(searching_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
if (searching_info->device_proxy) {
- g_dbus_proxy_call_sync(searching_info->device_proxy, "CancelDiscovery",
+ ret = g_dbus_proxy_call_sync(searching_info->device_proxy, "CancelDiscovery",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&err);
+ if (ret)
+ g_variant_unref(ret);
}
__bt_cancel_search_service_done();
gchar *device_path = NULL;
GDBusProxy *adapter_proxy;
GDBusProxy *device_proxy;
+ GVariant *ret = NULL;
GError *error = NULL;
GDBusConnection *conn;
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
g_free(device_path);
retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(device_proxy, "Set",
+ ret = g_dbus_proxy_call_sync(device_proxy, "Set",
g_variant_new("(ssv)", BT_DEVICE_INTERFACE, "Alias", g_variant_new("s", alias)),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
+ if (ret)
+ g_variant_unref(ret);
g_object_unref(device_proxy);
GError *error = NULL;
GDBusConnection *conn;
GVariant *result = NULL;
+ GVariant *temp = NULL;
int ret = BLUETOOTH_ERROR_NONE;
BT_CHECK_PARAMETER(device_address, return);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
return BLUETOOTH_ERROR_INTERNAL;
}
- previous_value = g_variant_get_boolean(result);
+ g_variant_get(result, "(v)", &temp);
+ previous_value = g_variant_get_boolean(temp);
+ g_variant_unref(temp);
g_variant_unref(result);
/* If the input is same with previous value, return error. */
if (previous_value == authorize) {
goto done;
}
- g_dbus_proxy_call_sync(device_proxy, "Set",
+ result = g_dbus_proxy_call_sync(device_proxy, "Set",
g_variant_new("(ssv)", BT_DEVICE_INTERFACE, "Trusted", g_variant_new("b", authorize)),
G_DBUS_CALL_FLAGS_NONE,
-1,
ret = BLUETOOTH_ERROR_INTERNAL;
}
done:
+ if (result)
+ g_variant_unref(result);
+
return ret;
}
BT_CHECK_PARAMETER(device_address, return);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
- NULL, BT_BLUEZ_NAME,
- object_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
+ NULL, BT_BLUEZ_NAME, object_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
g_free(object_path);
retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
- g_variant_new("(s)", BT_DEVICE_INTERFACE),
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
- &error);
- if (error != NULL || result == NULL) {
+ g_variant_new("(s)", BT_DEVICE_INTERFACE),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (result == NULL) {
if (error != NULL) {
BT_ERR("Error occured in Proxy call [%s]\n", error->message);
g_error_free(error);
g_variant_unref(result);
tmp_value = g_variant_lookup_value(value, "GattConnected", G_VARIANT_TYPE_BOOLEAN);
-
if (tmp_value == NULL) {
g_object_unref(device_proxy);
+ g_variant_unref(value);
return BLUETOOTH_ERROR_INTERNAL;
}
*is_connected = g_variant_get_boolean(tmp_value);
BT_DBG("gatt is connected : %d", *is_connected);
+
g_variant_unref(tmp_value);
g_variant_unref(value);
g_object_unref(device_proxy);
is_connected);
else if (connection_type == BLUETOOTH_GATT_SERVICE)
return _bt_is_gatt_connected(device_address, is_connected);
+ else if (connection_type == BLUETOOTH_PBAP_SERVICE)
+ return _bt_pbap_is_connected(device_address, is_connected);
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
- if (connection_type == BLUETOOTH_NAP_SERVER_SERVICE) {
+ if (connection_type == BLUETOOTH_NAP_SERVER_SERVICE) {
object_path = _bt_get_adapter_path();
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_BLUEZ_NAME,
g_free(object_path);
if (device_proxy == NULL) {
BT_DBG("Device don't have this service");
- return BLUETOOTH_ERROR_NONE;
+ return BLUETOOTH_ERROR_INTERNAL;
}
result = g_dbus_proxy_call_sync(device_proxy, "GetProperties",
&error);
if (result == NULL) {
- BT_ERR("Error occured in Proxy call");
+ BT_ERR("[GetProperties] Error occured in Proxy call");
if (error) {
- BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ BT_ERR("%s", error->message);
g_error_free(error);
}
+ *is_connected = FALSE;
g_object_unref(device_proxy);
return BLUETOOTH_ERROR_NONE;
}
uuid = _bt_get_profile_uuid128(connection_type);
if (uuid == NULL) {
BT_ERR("uuid is NULL");
- return BLUETOOTH_ERROR_NONE;
+ return BLUETOOTH_ERROR_INTERNAL;
}
BT_DBG("uuid: %s", uuid);
if (device_proxy == NULL) {
BT_DBG("Device don't have this service");
g_free(uuid);
- return BLUETOOTH_ERROR_NONE;
+ return BLUETOOTH_ERROR_INTERNAL;
}
result = g_dbus_proxy_call_sync(device_proxy, "IsConnectedProfile",
&error);
if (result == NULL) {
- BT_ERR("Error occured in Proxy call");
+ BT_ERR("[IsConnectedProfile] Error occured in Proxy call");
if (error) {
- BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ BT_ERR("%s", error->message);
+ if (g_strrstr(error->message, "Not Connected"))
+ BT_DBG("Not connected");
g_error_free(error);
}
- } else {
- g_variant_get(result, "(b)", is_connected);
+ *is_connected = FALSE;
+ g_object_unref(device_proxy);
g_free(uuid);
- g_variant_unref(result);
+ return BLUETOOTH_ERROR_NONE;
}
+ g_variant_get(result, "(b)", is_connected);
+ g_free(uuid);
+ g_variant_unref(result);
}
g_object_unref(device_proxy);
GVariant *value = NULL;
GVariant *result = NULL;
- int ret = BLUETOOTH_ERROR_NONE;
-
BT_CHECK_PARAMETER(device_address, return);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
g_variant_get(result , "(@a{sv})", &value);
g_variant_unref(result);
- tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BOOLEAN);
+ tmp_value = g_variant_lookup_value(value, "Connected", G_VARIANT_TYPE_BYTE);
if (tmp_value != NULL) {
+ *connected = g_variant_get_byte(tmp_value);
+ g_variant_unref(tmp_value);
g_object_unref(device_proxy);
- g_variant_unref(value);
+ return BLUETOOTH_ERROR_NONE;
+ } else {
+ BT_ERR("g_variant value is NULL");
return BLUETOOTH_ERROR_INTERNAL;
}
- *connected = g_variant_get_boolean(tmp_value);
- g_variant_unref(tmp_value);
- g_variant_unref(value);
- g_object_unref(device_proxy);
-
- return ret;
}
-static void __bt_connect_le_device_cb(GDBusProxy *proxy, GAsyncResult *res,
- gpointer user_data)
+static void __le_connection_req_cb(GDBusProxy *proxy, GAsyncResult *res,
+ gpointer user_data)
{
GError *err = NULL;
GVariant *out_param1;
- request_info_t *req_info;
- bluetooth_device_address_t device_addr = { {0} };
+ GVariant *reply;
int result = BLUETOOTH_ERROR_NONE;
+ bt_function_data_t *func_data = user_data;
+ request_info_t *req_info = NULL;
+ bluetooth_device_address_t device_addr = { {0} };
- BT_DBG("+");
- g_dbus_proxy_call_finish(proxy, res, &err);
+ reply = g_dbus_proxy_call_finish(proxy, res, &err);
+ g_object_unref(proxy);
- /* When cb datas of lescan are received, back to parameta values for Web TCT */
- if (_bt_is_set_scan_parameter() == FALSE) {
- bluetooth_le_scan_params_t scan_params;
- BT_ERR("set parameter of lescan when receive cb data");
- scan_params.type = BT_LE_ACTIVE_SCAN;
- scan_params.interval = 5000;
- scan_params.window = 500;
- _bt_set_scan_parameters(&scan_params);
+ if (reply == NULL) {
+ BT_ERR("ConnectLE / DisconnectLE DBus call error");
+ if (err) {
+ BT_ERR("Error: %s", err->message);
+ g_clear_error(&err);
+ }
+ result = BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ g_variant_unref(reply);
}
- req_info = _bt_get_request_info(le_connection_info->req_id);
- if (req_info == NULL) {
- BT_ERR("req_info == NULL");
- g_object_unref(proxy);
- le_connection_info->device_proxy = NULL;
+ if (func_data == NULL) {
+ BT_ERR("func_data is NULL");
goto done;
}
- if (err != NULL) {
- BT_ERR("Error occured in ConnectLE [%s]", err->message);
-
- if (g_strrstr(err->message, "NotSupported")) {
- BT_INFO("Connection Not Supported");
- result = BLUETOOTH_ERROR_CONNECTION_ERROR;
- } else if (g_strrstr(err->message, "AlreadyConnected")) {
- BT_INFO("Connection already exists");
- result = BLUETOOTH_ERROR_ALREADY_CONNECT;
- } else if (g_strrstr(err->message, "Connection Timeout")) {
- BT_INFO("Connection Timeout");
- result = BLUETOOTH_ERROR_TIMEOUT;
- } else {
- BT_DBG("Default case");
- result = BLUETOOTH_ERROR_CONNECTION_ERROR;
- }
+ req_info = _bt_get_request_info(func_data->req_id);
+ if (req_info == NULL) {
+ BT_ERR("req_info is NULL");
+ goto done;
}
- g_object_unref(proxy);
- le_connection_info->device_proxy = NULL;
+ if (req_info->context == NULL) {
+ BT_ERR("req_info->context is NULL");
+ goto done;
+ }
_bt_convert_addr_string_to_type(device_addr.addr,
- le_connection_info->addr);
-
- if (req_info->context == NULL)
- goto done;
+ (const char *)func_data->address);
out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
- &device_addr, sizeof(bluetooth_device_address_t), TRUE, NULL, NULL);
+ &device_addr, sizeof(bluetooth_device_address_t), TRUE,
+ NULL, NULL);
+
g_dbus_method_invocation_return_value(req_info->context,
g_variant_new("(iv)", result, out_param1));
- g_variant_unref(out_param1);
-
- _bt_delete_request_list(req_info->req_id);
done:
- if (err)
- g_error_free(err);
-
- g_free(le_connection_info->addr);
- g_free(le_connection_info);
- le_connection_info = NULL;
+ if (req_info)
+ _bt_delete_request_list(req_info->req_id);
- BT_DBG("-");
+ if (func_data) {
+ g_free(func_data->address);
+ g_free(func_data);
+ }
}
-int _bt_connect_le_device(int request_id,
- const bluetooth_device_address_t *bd_addr,
- gboolean auto_connect)
+static int __bt_connect_le_device_internal(int req_id, const bluetooth_device_address_t *bd_addr,
+ gboolean auto_connect)
{
char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
gchar *device_path = NULL;
GDBusProxy *device_proxy = NULL;
- GDBusProxy *adapter_proxy;
GDBusConnection *conn;
int ret = BLUETOOTH_ERROR_NONE;
+ bt_function_data_t *func_data;
BT_CHECK_PARAMETER(bd_addr, return);
- _bt_convert_addr_type_to_string(device_address,
- (unsigned char *)bd_addr->addr);
-
- if (le_connection_info) {
- BT_ERR("LE Connection in progress");
- return BLUETOOTH_ERROR_DEVICE_BUSY;
- }
-
-/* When auto_connect is true, Web TCT fail. It need to be checked */
- auto_connect = FALSE;
-
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- adapter_proxy = _bt_get_adapter_proxy();
- retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
-
+ _bt_convert_addr_type_to_string(device_address,
+ (unsigned char *)bd_addr->addr);
device_path = _bt_get_device_object_path(device_address);
if (device_path == NULL) {
- BT_DBG("device_path NULL");
+ BT_ERR_C("device_path NULL : [%s]", device_address);
ret = BLUETOOTH_ERROR_INTERNAL;
return ret;
}
- retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
-
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
- NULL, BT_BLUEZ_NAME,
- device_path, BT_DEVICE_INTERFACE, NULL, NULL);
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_DEVICE_INTERFACE, NULL, NULL);
g_free(device_path);
retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+ func_data = g_malloc0(sizeof(bt_function_data_t));
+ if (func_data == NULL) {
+ BT_ERR("Unable to allocate memory for address");
+ ret = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+ goto fail;
+ }
- le_connection_info = g_malloc0(sizeof(bt_funcion_data_t));
- le_connection_info->addr = g_strdup(device_address);
- le_connection_info->req_id = request_id;
- le_connection_info->device_proxy = device_proxy;
-
-/* The connection between Ble device and TM1 often fail. So It need to be set for Web TCT*/
- if (_bt_is_set_scan_parameter() == FALSE) {
- BT_ERR("set parameter of le scan when connect device");
- bluetooth_le_scan_params_t scan_params;
- scan_params.type = BT_LE_ACTIVE_SCAN;
- scan_params.interval = 60;
- scan_params.window = 60;
- _bt_set_scan_parameters(&scan_params);
+ func_data->address = g_strdup(device_address);
+ if (func_data->address == NULL) {
+ BT_ERR("Unable to allocate memory for address");
+ ret = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+ goto fail;
}
- auto_connect = FALSE;
+ func_data->req_id = req_id;
g_dbus_proxy_call(device_proxy, "ConnectLE",
- g_variant_new("(b)", auto_connect),
- G_DBUS_CALL_FLAGS_NONE,
- BT_MAX_DBUS_TIMEOUT,
- NULL,
- (GAsyncReadyCallback)__bt_connect_le_device_cb,
- NULL);
+ g_variant_new("(b)", auto_connect),
+ G_DBUS_CALL_FLAGS_NONE,
+ BT_MAX_DBUS_TIMEOUT,
+ NULL,
+ (GAsyncReadyCallback)__le_connection_req_cb, func_data);
+ return ret;
+fail:
+ if (device_proxy)
+ g_object_unref(device_proxy);
+ if (func_data) {
+ g_free(func_data->address);
+ g_free(func_data);
+ }
return ret;
}
-static void __bt_disconnect_le_device_cb(GDBusProxy *proxy, GAsyncResult *res,
- gpointer user_data)
+static gboolean __bt_connect_le_timer_cb(gpointer user_data)
{
- GError *err = NULL;
- GVariant *out_param1;
- request_info_t *req_info;
- bt_funcion_data_t *le_disconnection_info = user_data;
- bluetooth_device_address_t device_addr = { {0} };
- int result = BLUETOOTH_ERROR_NONE;
+ BT_INFO("Try to initiate pending LE connection");
- BT_DBG("+");
- g_dbus_proxy_call_finish(proxy, res, &err);
+ pending_le_conn_timer_id = 0;
- req_info = _bt_get_request_info(le_disconnection_info->req_id);
- if (req_info == NULL) {
- BT_ERR("req_info == NULL");
- g_object_unref(proxy);
- le_disconnection_info->device_proxy = NULL;
- goto done;
- }
-
- if (err != NULL) {
- BT_ERR("Error occured in DisconnectLE [%s]", err->message);
+ __bt_connect_le_device_internal(pending_le_conn_info->req_id,
+ &pending_le_conn_info->bd_addr,
+ pending_le_conn_info->auto_connect);
- if (g_strrstr(err->message, "NotSupported")) {
- BT_INFO("Connection Not Supported");
- result = BLUETOOTH_ERROR_CONNECTION_ERROR;
- } else if (g_strrstr(err->message, "NotConnected")) {
- BT_INFO("Connection does not exists");
- result = BLUETOOTH_ERROR_NOT_CONNECTED;
- } else if (g_strrstr(err->message, "Cancelled")) {
- BT_INFO("User Cancelled");
- result = BLUETOOTH_ERROR_CANCEL_BY_USER;
- } else {
- BT_DBG("Default case");
- result = BLUETOOTH_ERROR_CONNECTION_ERROR;
- }
- }
+ g_free(pending_le_conn_info);
+ pending_le_conn_info = NULL;
- g_object_unref(proxy);
- le_disconnection_info->device_proxy = NULL;
+ return FALSE;
+}
- _bt_convert_addr_string_to_type(device_addr.addr,
- le_disconnection_info->addr);
+void _bt_pending_connect_le_device(void)
+{
+ if (pending_le_conn_timer_id > 0) {
+ g_source_remove(pending_le_conn_timer_id);
+ __bt_connect_le_timer_cb(NULL);
+ }
+}
- if (req_info->context == NULL)
- goto done;
+int _bt_connect_le_device(int req_id, const bluetooth_device_address_t *bd_addr,
+ gboolean auto_connect)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
- out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
- &device_addr, sizeof(bluetooth_device_address_t), TRUE, NULL, NULL);
+ BT_CHECK_PARAMETER(bd_addr, return);
- g_dbus_method_invocation_return_value(req_info->context,
- g_variant_new("(iv)", result, out_param1));
+ ret = _bt_hold_current_advertising();
+ if (ret == BLUETOOTH_ERROR_NONE) {
+ BT_INFO("Current advertising is held");
+ pending_le_conn_info = g_malloc0(sizeof(bt_pending_le_conn_info_s));
+ pending_le_conn_info->req_id = req_id;
+ memcpy(pending_le_conn_info->bd_addr.addr, bd_addr->addr,
+ BLUETOOTH_ADDRESS_LENGTH);
+ pending_le_conn_info->auto_connect = auto_connect;
- g_variant_unref(out_param1);
+ pending_le_conn_timer_id =
+ g_timeout_add(1000, __bt_connect_le_timer_cb, NULL);
- _bt_delete_request_list(req_info->req_id);
-done:
- if (err)
- g_error_free(err);
+ return BLUETOOTH_ERROR_NONE;
+ }
- g_free(le_disconnection_info->addr);
- g_free(le_disconnection_info);
- le_disconnection_info = NULL;
+ BT_ERR("Unable to hold advertising");
- BT_DBG("-");
+ return __bt_connect_le_device_internal(req_id, bd_addr, auto_connect);
}
-int _bt_disconnect_le_device(int request_id,
+int _bt_disconnect_le_device(int req_id,
const bluetooth_device_address_t *bd_addr)
{
char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
- gchar *device_path = NULL;
- GDBusProxy *device_proxy = NULL;
- GDBusProxy *adapter_proxy;
+ gchar *device_path;
+ GDBusProxy *device_proxy;
GDBusConnection *conn;
int ret = BLUETOOTH_ERROR_NONE;
- bt_funcion_data_t *le_disconnection_info = NULL;
+ bt_function_data_t *func_data;
BT_CHECK_PARAMETER(bd_addr, return);
- _bt_convert_addr_type_to_string(device_address,
- (unsigned char *)bd_addr->addr);
-
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- adapter_proxy = _bt_get_adapter_proxy();
- retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
-
+ _bt_convert_addr_type_to_string(device_address,
+ (unsigned char *)bd_addr->addr);
device_path = _bt_get_device_object_path(device_address);
if (device_path == NULL) {
BT_DBG("device_path NULL");
retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
- NULL, BT_BLUEZ_NAME,
- device_path, BT_DEVICE_INTERFACE, NULL, NULL);
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_DEVICE_INTERFACE, NULL, NULL);
g_free(device_path);
retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- le_disconnection_info = g_malloc0(sizeof(bt_funcion_data_t));
- le_disconnection_info->addr = g_strdup(device_address);
- le_disconnection_info->req_id = request_id;
- le_disconnection_info->device_proxy = device_proxy;
+ func_data = g_malloc0(sizeof(bt_function_data_t));
+ if (func_data == NULL) {
+ BT_ERR("Unable to allocate memory for address");
+ ret = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+ goto fail;
+ }
+
+ func_data->address = g_strdup(device_address);
+ if (func_data->address == NULL) {
+ BT_ERR("Unable to allocate memory for address");
+ ret = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+ goto fail;
+ }
+
+ func_data->req_id = req_id;
g_dbus_proxy_call(device_proxy, "DisconnectLE",
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- BT_MAX_DBUS_TIMEOUT,
- NULL,
- (GAsyncReadyCallback)__bt_disconnect_le_device_cb,
- le_disconnection_info);
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ BT_MAX_DBUS_TIMEOUT,
+ NULL,
+ (GAsyncReadyCallback)__le_connection_req_cb, func_data);
+ return ret;
+fail:
+ if (device_proxy)
+ g_object_unref(device_proxy);
+ if (func_data) {
+ g_free(func_data->address);
+ g_free(func_data);
+ }
return ret;
}
_bt_convert_addr_type_to_string(device_address,
(unsigned char *)bd_addr->addr);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_proxy = _bt_get_adapter_proxy();
_bt_convert_addr_type_to_string(device_address,
(unsigned char *)bd_addr->addr);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_proxy = _bt_get_adapter_proxy();
GDBusProxy *proxy;
GDBusConnection *conn;
GDBusProxy *adapter_proxy;
+ GVariant *result = NULL;
GError *error = NULL;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
object_path = _bt_get_device_object_path(address);
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(adapter_proxy, "CreateDevice",
+ result = g_dbus_proxy_call_sync(adapter_proxy, "CreateDevice",
g_variant_new("(s)", address),
G_DBUS_CALL_FLAGS_NONE,
-1,
BT_ERR("CreateDevice Fail: %s", error->message);
g_error_free(error);
}
+ if (result)
+ g_variant_unref(result);
object_path = _bt_get_device_object_path(address);
}
GDBusProxy *proxy;
GDBusConnection *conn;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
object_path = _bt_get_device_object_path(address);
{
int ret = BLUETOOTH_ERROR_NONE;
GDBusProxy *proxy;
+ GVariant *result = NULL;
GError *error = NULL;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
proxy = _bt_get_adapter_proxy();
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(proxy, "EnableRssi",
+ result = g_dbus_proxy_call_sync(proxy, "EnableRssi",
g_variant_new("(siiii)", address, link_type, low_threshold, in_range_threshold, high_threshold),
G_DBUS_CALL_FLAGS_NONE,
-1,
g_error_free(error);
ret = BLUETOOTH_ERROR_INTERNAL;
}
+
+ if (result)
+ g_variant_unref(result);
+
return ret;
}
{
int ret = BLUETOOTH_ERROR_NONE;
GDBusProxy *proxy;
+ GVariant *result = NULL;
GError *error = NULL;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
proxy = _bt_get_adapter_proxy();
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(proxy, "GetRssiStrength",
+ result = g_dbus_proxy_call_sync(proxy, "GetRssiStrength",
g_variant_new("(si)", address, link_type),
G_DBUS_CALL_FLAGS_NONE,
-1,
g_error_free(error);
ret = BLUETOOTH_ERROR_INTERNAL;
}
+
+ if (result)
+ g_variant_unref(result);
+
return ret;
}
int _bt_le_conn_update(unsigned char *device_address,
- guint16 interval_min, guint16 interval_max,
+ float interval_min, float interval_max,
guint16 latency, guint16 time_out)
{
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
guint32 min_supervision_to;
int ret = BLUETOOTH_ERROR_NONE;
- BT_DBG("+");
-
BT_CHECK_PARAMETER(device_address, return);
- BT_DBG("Min interval: %u, Max interval: %u, Latency: %u, Supervision timeout: %u",
+ BT_INFO("Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
interval_min, interval_max, latency, time_out);
if (interval_min > interval_max ||
device_path = _bt_get_device_object_path(address);
if (device_path == NULL) {
- BT_DBG("device_path NULL");
+ BT_ERR("device_path NULL");
ret = BLUETOOTH_ERROR_INTERNAL;
goto fail;
}
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL) {
- BT_DBG("conn NULL");
+ BT_ERR("conn NULL");
ret = BLUETOOTH_ERROR_INTERNAL;
goto fail;
}
&error);
g_object_unref(device_proxy);
- BT_ERR("LeConnUpdate Call Error for %s", address);
if (reply == NULL) {
if (error) {
BT_ERR("Error %s[%s]", error->message, address);
+ if (g_strrstr(error->message, "In Progress"))
+ ret = BLUETOOTH_ERROR_IN_PROGRESS;
+ else
+ ret = BLUETOOTH_ERROR_INTERNAL;
g_error_free(error);
- return BLUETOOTH_ERROR_INTERNAL;
+ return ret;
}
}
g_variant_unref(reply);
- BT_DBG("-");
fail:
return ret;
}
pin_info = g_malloc0(sizeof(bt_pin_code_info_t));
- if (pin_info != NULL) {
- pin_info->address = g_strdup(address);
- pin_info->pin_code = g_strdup(pin_code->pin_code);
- pin_info_list = g_slist_append(pin_info_list, pin_info);
- return BLUETOOTH_ERROR_NONE;
- }
+ pin_info->address = g_strdup(address);
+ pin_info->pin_code = g_strdup(pin_code->pin_code);
+ pin_info_list = g_slist_append(pin_info_list, pin_info);
- return BLUETOOTH_ERROR_INTERNAL;
+ return BLUETOOTH_ERROR_NONE;
}
gint __bt_compare_address(gpointer *a, gpointer *b)
return BLUETOOTH_ERROR_NONE;
}
+int _bt_get_trusted_profile_from_flag(bluetooth_trusted_profile_t profile,
+ guint trusted_profile_flag, guint *trusted)
+{
+ int trust_profile;
+ *trusted = FALSE;
+
+ switch (profile) {
+ case TRUSTED_PROFILE_PBAP:
+ if (trusted_profile_flag & (PROFILE_SUPPORTED << 0))
+ trust_profile = trusted_profile_flag & (1 << 1);
+ else
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ break;
+ case TRUSTED_PROFILE_MAP:
+ if (trusted_profile_flag & (PROFILE_SUPPORTED << 2))
+ trust_profile = trusted_profile_flag & (1 << 3);
+ else
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ break;
+ case TRUSTED_PROFILE_SAP:
+ if (trusted_profile_flag & (PROFILE_SUPPORTED << 4))
+ trust_profile = trusted_profile_flag & (1 << 5);
+ else
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ break;
+ case TRUSTED_PROFILE_ALL: /* Return Flag for All profiles*/
+ *trusted = trusted_profile_flag;
+ return BLUETOOTH_ERROR_NONE;
+ default:
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (trust_profile)
+ *trusted = TRUE;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_get_restricted_profile_from_flag(bluetooth_restricted_profile_t profile,
+ guint restricted_profile_flag, guint *restricted)
+{
+ int restrict_profile;
+ *restricted = FALSE;
+
+ switch (profile) {
+ case RESTRICTED_PROFILE_HFP_HS:
+ restrict_profile = restricted_profile_flag & (1 << 0);
+ break;
+ case RESTRICTED_PROFILE_A2DP:
+ restrict_profile = restricted_profile_flag & (1 << 2);
+ break;
+ default:
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (restrict_profile)
+ *restricted = TRUE;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+char *_bt_get_trusted_profile_uuid(bluetooth_trusted_profile_t profile)
+{
+ switch (profile) {
+ case TRUSTED_PROFILE_PBAP:
+ return g_strdup("00001130-0000-1000-8000-00805f9b34fb");
+ case TRUSTED_PROFILE_MAP:
+ return g_strdup("00001134-0000-1000-8000-00805f9b34fb");
+ case TRUSTED_PROFILE_SAP:
+ return g_strdup("0000112D-0000-1000-8000-00805f9b34fb");
+ case TRUSTED_PROFILE_ALL:
+ return NULL;
+ }
+
+ return NULL;
+}
+
+char *_bt_get_restricted_profile_uuid(bluetooth_restricted_profile_t profile)
+{
+ switch (profile) {
+ case RESTRICTED_PROFILE_HFP_HS:
+ return g_strdup("0000111e-0000-1000-8000-00805f9b34fb");
+ case RESTRICTED_PROFILE_A2DP:
+ return g_strdup("0000110b-0000-1000-8000-00805f9b34fb");
+ }
+
+ return NULL;
+}
+
+bluetooth_trusted_profile_t _bt_get_trusted_profile_enum(const char *uuid)
+{
+ if (g_strcmp0("0000112f-0000-1000-8000-00805f9b34fb", uuid) == 0)
+ return TRUSTED_PROFILE_PBAP;
+ else if (g_strcmp0("00001132-0000-1000-8000-00805f9b34fb", uuid) == 0)
+ return TRUSTED_PROFILE_MAP;
+ else if (g_strcmp0("0000112D-0000-1000-8000-00805f9b34fb", uuid) == 0)
+ return TRUSTED_PROFILE_SAP;
+
+ return 0; /* 0 - Unknown Profile */
+}
+
+int _bt_set_trust_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_trusted_profile_t profile, gboolean trust)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ char *uuid = NULL;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] trust[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, trust);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_DEVICE_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ uuid = _bt_get_trusted_profile_uuid(profile);
+ if (uuid == NULL) {
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ reply = g_dbus_proxy_call_sync(proxy, "SetTrustedProfile",
+ g_variant_new("(sb)", uuid, trust),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Set Profile Trusted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ goto finish;
+ }
+ g_variant_unref(reply);
+
+finish:
+ g_free(uuid);
+ return ret;
+}
+
+int _bt_get_trust_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_trusted_profile_t profile, guint *trust)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ guint trusted_profile_flag;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] trust[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, *trust);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ reply = g_dbus_proxy_call_sync(proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "TrustedProfiles"),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Get Profile Trusted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ *trust = 0;
+ } else {
+ GVariant *temp;
+ g_variant_get(reply, "(v)", &temp);
+ trusted_profile_flag = g_variant_get_uint32(temp);
+ BT_DBG("TRUST_FLAG %d", trusted_profile_flag);
+
+ ret = _bt_get_trusted_profile_from_flag(profile,
+ trusted_profile_flag, trust);
+ g_variant_unref(temp);
+ g_variant_unref(reply);
+ }
+
+ BT_DBG("TRUST %d", *trust);
+ return ret;
+}
+
+int _bt_set_restrict_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_restricted_profile_t profile, gboolean restricted)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ char *uuid = NULL;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] restricted[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, restricted);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_DEVICE_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ uuid = _bt_get_restricted_profile_uuid(profile);
+ if (uuid == NULL) {
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ reply = g_dbus_proxy_call_sync(proxy, "SetRestrictedProfile",
+ g_variant_new("(sb)", uuid, restricted),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Set Profile Restricted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ goto finish;
+ }
+ g_variant_unref(reply);
+
+finish:
+ g_free(uuid);
+ return ret;
+}
+
+int _bt_get_restrict_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_restricted_profile_t profile, guint *restricted)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ guint restricted_profile_flag;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] restricted[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, *restricted);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ reply = g_dbus_proxy_call_sync(proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "RestrictedProfiles"),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Get Profile Restricted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ *restricted = 0;
+ } else {
+ GVariant *temp;
+ g_variant_get(reply, "(v)", &temp);
+ restricted_profile_flag = g_variant_get_uint32(temp);
+ BT_DBG("Restricted_FLAG %d", restricted_profile_flag);
+
+ ret = _bt_get_restricted_profile_from_flag(profile,
+ restricted_profile_flag, restricted);
+ g_variant_unref(temp);
+ g_variant_unref(reply);
+ }
+
+ BT_DBG("TRUST %d", *restricted);
+ return ret;
+}
+
+static void __bt_request_att_mtu_device_cb(GDBusProxy *proxy, GAsyncResult *res,
+ gpointer user_data)
+{
+ GError *err = NULL;
+ GVariant *out_param1;
+ request_info_t *req_info;
+ GVariant *val = NULL;
+ GVariant *param = NULL;
+ guint8 status = 0;
+ guint16 mtu = 0;
+ bluetooth_device_address_t device_addr = { {0} };
+ int result = BLUETOOTH_ERROR_NONE;
+
+ BT_DBG("+");
+ val = g_dbus_proxy_call_finish(proxy, res, &err);
+
+ req_info = _bt_get_request_info(att_mtu_req_info->req_id);
+ if (req_info == NULL) {
+ BT_ERR("req_info == NULL");
+ g_object_unref(proxy);
+ att_mtu_req_info->device_proxy = NULL;
+ goto done;
+ }
+
+ if (err != NULL) {
+ BT_ERR("Error occured in RequestAttMtu [%s]", err->message);
+
+ if (g_strrstr(err->message, "NotSupported")) {
+ BT_INFO("Connection Not Supported");
+ result = BLUETOOTH_ERROR_NOT_SUPPORT;
+ } else if (g_strrstr(err->message, "NotConnected")) {
+ BT_INFO("Not connected");
+ result = BLUETOOTH_ERROR_NOT_CONNECTED;
+ } else if (g_strrstr(err->message, "InvalidArguments")) {
+ BT_INFO("Not connected");
+ result = BLUETOOTH_ERROR_INVALID_PARAM;
+ } else {
+ BT_DBG("Default case");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ }
+
+ g_object_unref(proxy);
+ att_mtu_req_info->device_proxy = NULL;
+
+ if (result != BLUETOOTH_ERROR_NONE)
+ goto dbus_return;
+
+ if (val) {
+ g_variant_get(val, "(qy)", &mtu, &status);
+ g_variant_unref(val);
+ }
+
+ BT_DBG("MTU %d, Status %d, %s", mtu, status, att_mtu_req_info->addr);
+
+ param = g_variant_new("(isqy)",
+ result,
+ att_mtu_req_info->addr,
+ mtu,
+ status);
+
+ /* Send the event to application */
+ _bt_send_event(BT_DEVICE_EVENT,
+ BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
+ param);
+
+dbus_return:
+ if (req_info->context == NULL)
+ goto done;
+
+ _bt_convert_addr_string_to_type(device_addr.addr,
+ (const char *)att_mtu_req_info->addr);
+
+ out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
+ &device_addr, sizeof(bluetooth_device_address_t), TRUE, NULL, NULL);
+ g_dbus_method_invocation_return_value(req_info->context,
+ g_variant_new("(iv)", result, out_param1));
+
+ _bt_delete_request_list(req_info->req_id);
+done:
+ if (err)
+ g_error_free(err);
+
+ g_free(att_mtu_req_info->addr);
+ g_free(att_mtu_req_info);
+ att_mtu_req_info = NULL;
+
+ BT_DBG("-");
+}
+
+int _bt_request_att_mtu(int request_id, bluetooth_device_address_t *device_address,
+ unsigned int mtu)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ gchar *device_path = NULL;
+ GDBusProxy *adapter_proxy;
+ GDBusProxy *device_proxy;
+ GDBusConnection *conn;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ if (att_mtu_req_info) {
+ BT_ERR("ATT MTU request in progress");
+ return BLUETOOTH_ERROR_DEVICE_BUSY;
+ }
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ adapter_proxy = _bt_get_adapter_proxy();
+ retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ BT_DBG("Remote device address: %s", address);
+
+ device_path = _bt_get_device_object_path(address);
+
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_DEVICE_INTERFACE, NULL, NULL);
+ g_free(device_path);
+ retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ if (device_path == NULL) {
+ BT_DBG("device_path NULL");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ goto fail;
+ }
+
+ att_mtu_req_info = g_malloc0(sizeof(bt_funcion_data_t));
+ att_mtu_req_info->addr = (char *)g_strdup(address);
+ att_mtu_req_info->req_id = request_id;
+ att_mtu_req_info->device_proxy = device_proxy;
+
+ g_dbus_proxy_call(device_proxy, "RequestAttMtu",
+ g_variant_new("(q)", mtu),
+ G_DBUS_CALL_FLAGS_NONE,
+ BT_MAX_DBUS_TIMEOUT,
+ NULL,
+ (GAsyncReadyCallback)__bt_request_att_mtu_device_cb,
+ NULL);
+fail:
+ return ret;
+}
+
+int _bt_get_att_mtu(bluetooth_device_address_t *device_address,
+ unsigned int *mtu)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char *object_path = NULL;
+
+ GDBusProxy *device_proxy;
+ GError *error = NULL;
+ GVariant *value;
+ GVariant *tmp_value;
+ GDBusConnection *conn;
+ GVariant *result = NULL;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ object_path = _bt_get_device_object_path(address);
+ retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, object_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
+ g_free(object_path);
+ retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
+ g_variant_new("(s)", BT_DEVICE_INTERFACE),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (result == NULL) {
+ if (error != NULL) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(device_proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_variant_get(result , "(@a{sv})", &value);
+ g_variant_unref(result);
+
+ tmp_value = g_variant_lookup_value(value, "AttMtu", G_VARIANT_TYPE_UINT16);
+ if (tmp_value == NULL) {
+ g_object_unref(device_proxy);
+ g_variant_unref(value);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ *mtu = g_variant_get_uint16(tmp_value);
+
+ BT_DBG("ATT MTU : %d", *mtu);
+
+ g_variant_unref(tmp_value);
+ g_variant_unref(value);
+ g_object_unref(device_proxy);
+
+ return ret;
+}
+
+int _bt_get_device_ida(bluetooth_device_address_t *device_address,
+ bluetooth_device_address_t *id_address)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ gchar *device_path = NULL;
+ const gchar *idaddress = NULL;
+ GDBusProxy *device_proxy;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GDBusConnection *conn;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_DEVICE_INTERFACE, NULL, NULL);
+ g_free(device_path);
+ if (!device_proxy) {
+ BT_ERR("Unable to get proxy");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ result = g_dbus_proxy_call_sync(device_proxy, "GetIDAddress",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+
+ if (result == NULL) {
+ BT_ERR("Failed to get device ID address");
+ if (error != NULL) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(device_proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ g_variant_get(result , "(s)", &idaddress);
+ g_variant_unref(result);
+
+ if (idaddress == NULL) {
+ BT_ERR("No paired device");
+ g_object_unref(device_proxy);
+ return BLUETOOTH_ERROR_NOT_PAIRED;
+ }
+
+ BT_DBG("ID Address:%s", idaddress);
+
+ if (idaddress)
+ _bt_convert_addr_string_to_type(id_address->addr, idaddress);
+ else
+ ret = BLUETOOTH_ERROR_INTERNAL;
+
+ g_object_unref(device_proxy);
+
+ return ret;
+}
+
int _bt_passkey_reply(const char *passkey, gboolean authentication_reply)
{
GapAgentPrivate *agent = _bt_get_adapter_agent();
if (list) {
ret = DPM_RESULT_SUCCESS;
for (; list; list = list->next, i++) {
- memset(device_list.addresses[i].addr, 0, BT_ADDRESS_STRING_SIZE);
+ memset(device_list.addresses[i].addr, 0, BLUETOOTH_ADDRESS_LENGTH);
_bt_convert_addr_string_to_type(device_list.addresses[i].addr, list->data);
}
device_list.count = g_slist_length(policy_table[DPM_POLICY_BLUETOOTH_DEVICES_BLACKLIST].list);
if (list) {
ret = DPM_RESULT_SUCCESS;
for (; list; list = list->next, i++) {
- memset(device_list.addresses[i].addr, 0, BT_ADDRESS_STRING_SIZE);
+ memset(device_list.addresses[i].addr, 0, BLUETOOTH_ADDRESS_LENGTH);
_bt_convert_addr_string_to_type(device_list.addresses[i].addr, list->data);
}
if (_bt_dpm_get_allow_bluetooth_mode() == DPM_BT_RESTRICTED)
return ret;
-
+
if (list) {
ret = DPM_RESULT_SUCCESS;
uuids_list.count = g_slist_length(policy_table[DPM_POLICY_BLUETOOTH_UUIDS_WHITELIST].list);
#include "bt-service-pbap.h"
#include "bt-service-headset-connection.h"
#include "bt-service-avrcp-controller.h"
+#include "bt-service-hid.h"
+#include "bt-service-proximity.h"
#include "bt-service-opp-client.h"
static GList *p_cache_list = NULL;
static guint event_id;
+static guint session_reinit_timer;
guint nap_connected_device_count = 0;
static guint hid_connected_device_count = 0;
-static GList *p_adv_ind_list;
+static GList *p_adv_ind_list = NULL;
typedef struct {
bt_remote_dev_info_t *dev_info;
OBEX_PBAP = (1 << 4),
OBEX_IRMC = (1 << 5),
OBEX_PCSUITE = (1 << 6),
- OBEX_SYNCEVOLUTION = (1 << 7),
+ OBEX_SYNCEVOLUTION = (1 << 7),
OBEX_MAS = (1 << 8),
} bluetooth_obex_connection_type_t;
void __bt_gatt_char_property_changed_event(GVariant *msg_iter,
const char *path);
-static void __bt_free_bt_le_adv_info_t(bt_le_adv_info_t *adv_info)
+static void __bt_free_bt_le_adv_info_t(gpointer data)
{
+ bt_le_adv_info_t *adv_info = data;
+
+ if (adv_info->timer_id)
+ g_source_remove(adv_info->timer_id);
+ adv_info->timer_id = 0;
+
g_free(adv_info->addr);
g_free(adv_info->data);
g_free(adv_info);
GList *current = g_list_first((GList *)p_adv_ind_list);
while (current && current->data) {
adv_info = (bt_le_adv_info_t *)current->data;
- retv_if(adv_info && !g_strcmp0(adv_info->addr, addr), adv_info);
+ if (adv_info && !g_strcmp0(adv_info->addr, addr))
+ return adv_info;
current = g_list_next(current);
}
return NULL;
}
-static void __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info)
+static int __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info)
{
- ret_if(!adv_info);
+ retv_if(!adv_info, -1);
if (__bt_get_adv_ind_info(adv_info->addr) != NULL) {
- BT_ERR("adv_info is already added");
__bt_free_bt_le_adv_info_t(adv_info);
- return;
+ return -1;
}
p_adv_ind_list = g_list_append(p_adv_ind_list, adv_info);
+
+ return 0;
}
static void __bt_del_adv_ind_info(char *addr)
}
}
+static gboolean __bt_adv_scan_req_timeout_cb(gpointer user_data)
+{
+ bt_remote_le_dev_info_t le_dev_info;
+ bt_le_adv_info_t *adv_info = (bt_le_adv_info_t*)user_data;
+
+ memset(&le_dev_info, 0x00, sizeof(bt_remote_le_dev_info_t));
+
+ le_dev_info.address = adv_info->addr;
+ le_dev_info.addr_type = adv_info->addr_type;
+ le_dev_info.rssi = adv_info->rssi;
+ le_dev_info.adv_data = adv_info->data;
+ le_dev_info.adv_data_len = 0;
+ adv_info->timer_id = 0;
+
+ _bt_send_scan_result_event(&le_dev_info, adv_info);
+ __bt_del_adv_ind_info(adv_info->addr);
+
+ return FALSE;
+}
+
static void __bt_free_cache_info(bt_cache_info_t *cache_info)
{
ret_if(cache_info == NULL);
if (dev_info->name == NULL)
dev_info->name = g_variant_dup_string(val, &len);
} else if (strcasecmp(key, "Connected") == 0) {
- dev_info->connected = g_variant_get_uint32(val);
+ dev_info->connected = g_variant_get_byte(val);
} else if (strcasecmp(key, "paired") == 0) {
dev_info->paired = g_variant_get_boolean(val);
} else if (strcasecmp(key, "Trusted") == 0) {
g_free(uuid_value);
}
} else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
- g_variant_get(val, "(i)", &dev_info->manufacturer_data_len);
+ g_variant_get(val, "q", &dev_info->manufacturer_data_len);
if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
if (dev_info->manufacturer_data_len == 0)
dev_info->manufacturer_data = g_strdup("");
} else if (strcasecmp(key, "ManufacturerData") == 0) {
+ int i = 0;
int len = 0;
- GVariant *manufacturer_var;
- g_variant_get(val, "@ay", &manufacturer_var);
- len = g_variant_get_size(manufacturer_var);
- if (len > 0) {
- char *manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
- dev_info->manufacturer_data = g_malloc0(len);
- if (dev_info->manufacturer_data)
- memcpy(dev_info->manufacturer_data, manufacturer_data,
- len);
- }
- g_variant_unref(manufacturer_var);
+ GVariantIter *value_iter;
+ guint8 m_value;
+
+ len = g_variant_get_size(val);
+ if (len <= 0)
+ continue;
+
+ dev_info->manufacturer_data = g_malloc0(len);
+
+ g_variant_get(val, "ay", &value_iter);
+ while (g_variant_iter_loop(value_iter, "y", &m_value))
+ dev_info->manufacturer_data[i++] = m_value;
+ g_variant_iter_free(value_iter);
}
}
bt_remote_dev_info_t *dev_info)
{
char *path = NULL;
- GVariant *optional_param;
+ GVariant *optional_param = NULL;
GVariantIter iter;
GVariant *child;
char *interface_name = NULL;
&path, &optional_param);
g_variant_iter_init(&iter, optional_param);
+ retv_if(optional_param == NULL, FALSE);
+
while ((child = g_variant_iter_next_value(&iter))) {
g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
}
}
g_variant_unref(inner_iter);
- g_variant_unref(child);
+ g_variant_unref(child);
}
g_variant_unref(optional_param);
{
int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
- if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) {
+ if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
BT_ERR("vconf_get_int failed");
- }
if (connected == TRUE)
bt_device_state |= state;
else if (bt_device_state & state)
bt_device_state ^= state;
- if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0) {
+ if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0)
BT_ERR("vconf_set_int failed");
- }
}
gboolean _bt_discovery_finished_cb(gpointer user_data)
event_id = 0;
GVariant *param = NULL;
if (_bt_get_discovering_property(DISCOVERY_ROLE_BREDR) == FALSE) {
- if (_bt_get_cancel_by_user() == TRUE) {
+ if (_bt_get_cancel_by_user() == TRUE)
result = BLUETOOTH_ERROR_CANCEL_BY_USER;
- }
_bt_set_cancel_by_user(FALSE);
_bt_set_discovery_status(FALSE);
event_id = 0;
GVariant *param = NULL;
if (_bt_get_discovering_property(DISCOVERY_ROLE_LE) == FALSE) {
- if (_bt_get_cancel_by_user() == TRUE) {
+ if (_bt_get_cancel_by_user() == TRUE)
result = BLUETOOTH_ERROR_CANCEL_BY_USER;
- }
+
+ g_list_free_full(p_adv_ind_list, __bt_free_bt_le_adv_info_t);
+ p_adv_ind_list = NULL;
_bt_set_cancel_by_user(FALSE);
- _bt_disable_all_scanner_status();
+ _bt_disable_all_scanner_status();
_bt_set_le_scan_status(FALSE);
param = g_variant_new("(i)", result);
_bt_send_event(BT_LE_ADAPTER_EVENT,
BT_DBG("-");
}
+gboolean __bt_handle_is_flight_mode_enabled(void)
+{
+#ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
+ int is_flight_mode = 0;
+ int ret = -1;
+
+ ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &is_flight_mode);
+ if (ret != 0)
+ BT_ERR("vconf_get_bool failed");
+
+ return (is_flight_mode == 0) ? FALSE : TRUE;
+#else
+ return FALSE;
+#endif
+}
+
void _bt_handle_adapter_event(GVariant *msg, const char *member)
{
BT_DBG("+");
g_variant_get(msg, "(&o)", &object_path);
_bt_convert_device_path_to_address((const char*)object_path, address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(object_path);
if (remote_dev_info == NULL) {
g_free(address);
return;
/* Bonding from remote device */
address = g_malloc0(BT_ADDRESS_STRING_SIZE);
- g_variant_get(msg, "(&o)", &object_path);
-
- /* Fix : NULL_RETURNS */
if (address == NULL)
return;
+ g_variant_get(msg, "(&o)", &object_path);
+
_bt_convert_device_path_to_address((const char *)object_path, address);
node = g_list_first(p_cache_list);
g_free(address);
} else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
BT_ERR_C("Hardware error received from BLUEZ");
+/* Don't add the recovery logic into platform */
+#if 0
_bt_recover_adapter();
+#endif
} else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
BT_ERR_C("Tx timeout error received from BLUEZ");
+/* Don't add the recovery logic into platform */
+#if 0
_bt_recover_adapter();
+#endif
}
BT_DBG("-");
}
int result = BLUETOOTH_ERROR_NONE;
GVariantIter value_iter;
GVariant *val = NULL;
+ GVariant *ret = NULL;
GError *err = NULL;
char *property = NULL;
GVariant *param = NULL;
ret_if(adapter_proxy == NULL);
/* Need to stop searching */
- g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery",
+ ret = g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery",
NULL,
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL,
BT_ERR("Dbus Error : %s", err->message);
g_clear_error(&err);
}
+ if (ret)
+ g_variant_unref(ret);
event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
(GSourceFunc)_bt_discovery_finished_cb, NULL);
ret_if(adapter_proxy == NULL);
/* Need to stop searching */
- g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery",
+ ret = g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery",
NULL,
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL,
BT_ERR("Dbus Error %s", err->message);
g_clear_error(&err);
}
+ if (ret)
+ g_variant_unref(ret);
event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
(GSourceFunc)__bt_le_discovery_finished_cb, NULL);
int time = 0;
adapter_proxy = _bt_get_adapter_properties_proxy();
ret_if(adapter_proxy == NULL);
- g_dbus_proxy_call_sync(adapter_proxy, "Set",
- g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
+ ret = g_dbus_proxy_call_sync(adapter_proxy, "Set",
+ g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
"DiscoverableTimeout",
g_variant_new("i", time)),
- G_DBUS_CALL_FLAGS_NONE,
- DBUS_TIMEOUT, NULL,
- &err);
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT, NULL,
+ &err);
if (err != NULL) {
BT_ERR("StopLEDiscovery Failed: %s", err->message);
g_error_free(err);
}
+ if (ret)
+ g_variant_unref(ret);
}
mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
#else
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_state) == 0 &&
bt_state != VCONFKEY_BT_STATUS_OFF) {
- _bt_disable_adapter();
+ if (__bt_handle_is_flight_mode_enabled() == FALSE)
+ _bt_disable_adapter();
+ else
+ _bt_handle_adapter_removed();
}
#endif
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_state) == 0 &&
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
param);
+#if 0
if (_bt_adapter_get_status() == BT_DEACTIVATING &&
_bt_adapter_get_le_status() == BT_LE_ACTIVATED &&
connectable == 0)
_bt_set_disabled(BLUETOOTH_ERROR_NONE);
+#endif
} else if (strcasecmp(property, "SupportedLEFeatures") == 0) {
char *name = NULL;
char *value = NULL;
GVariantIter *iter = NULL;
g_variant_get(val, "as", &iter);
- if (iter) {
- while (g_variant_iter_loop(iter, "s", &name)) {
- BT_DBG("name = %s", name);
- g_variant_iter_loop(iter, "s", &value);
- BT_DBG("Value = %s", value);
- if (FALSE == _bt_update_le_feature_support(name, value))
- BT_INFO("Fail to update LE feature info");
- }
- g_variant_iter_free(iter);
+ while (g_variant_iter_loop(iter, "s", &name)) {
+ BT_DBG("name = %s", name);
+ g_variant_iter_loop(iter, "s", &value);
+ BT_DBG("Value = %s", value);
+ if (FALSE == _bt_update_le_feature_support(name, value))
+ BT_INFO("Fail to update LE feature info");
}
+ if (iter)
+ g_variant_iter_free(iter);
} else if (strcasecmp(property, "IpspInitStateChanged") == 0) {
gboolean ipsp_initialized = FALSE;
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
param);
+ } else {
+ BT_DBG("property : [%s]", property);
}
}
}
}
g_free(status);
} else if (strcasecmp(property, "Transferred") == 0) {
- static int transferred = 0;
+ guint64 transferred = 0;
+ /* As Transferred is expected guint64 so change int to guint64 and
+ * eariler transferred is static because of it can overwrite data
+ * on present on opc_obex_conn or obexd_conn as these are
+ * static memory are in sequential */
g_variant_get(val, "t", &transferred);
_bt_obex_transfer_progress(path, transferred);
BT_DBG("connected: %d", connected);
BT_DBG("address: %s", address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info != NULL) {
__bt_device_remote_connected_properties(
_bt_convert_device_path_to_address(path, address);
BT_DBG("address: %s", address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info == NULL) {
g_free(property);
g_variant_unref(val);
_bt_convert_device_path_to_address(path, address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info == NULL) {
g_free(property);
g_variant_unref(val);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
param);
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+ {
+ char *last_connected = NULL;
+ last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
+ if (!g_strcmp0(address, last_connected))
+ _bt_audio_set_auto_connect_device_addr("");
+ if (last_connected)
+ free(last_connected);
+ }
+#endif
} else {
- BT_INFO("Paired: %s", address);
+ char secure_addr[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ _bt_convert_addr_string_to_secure_string(secure_addr, address);
+ BT_INFO("### Paired: %s", secure_addr);
__bt_update_remote_cache_devinfo(address, TRUE);
if (_bt_is_device_creating() == TRUE) {
} else if (strcasecmp(property, "LegacyPaired") == 0) {
gboolean paired = FALSE;
bt_remote_dev_info_t *remote_dev_info;
+ unsigned char auth_info[5] = {0, };
if (_bt_adapter_get_status() != BT_ACTIVATED) {
BT_DBG("BT is not activated, so ignore this");
BT_DBG("LegacyPaired: %d", paired);
_bt_convert_device_path_to_address(path, address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info == NULL) {
g_free(address);
g_free(property);
g_variant_unref(val);
return;
}
+ if (remote_dev_info->is_alias_set == FALSE) {
+ /*minimum Size of the samsung specific manufacturer data is greater than 30 */
+ if ((remote_dev_info->manufacturer_data_len > 30) &&
+ (remote_dev_info->manufacturer_data[0] == 0x00) &&
+ (remote_dev_info->manufacturer_data[1] == 0x75)) {
+
+ /* 2 samsung (0x00 0x75) + 1 (control and version) + 1 (service ID) +
+ 1 (discovery version) + 1 (associated service ID)
+ 2 (Proxamity and locality) + 2 (Device type and icon) = 10 */
+
+ memcpy(auth_info, &(remote_dev_info->manufacturer_data[10]), 5);
+ }
+ }
- BT_DBG("LegacyPairing Failed with %s. Show Error Popup",
- remote_dev_info->name);
+ BT_DBG("LegacyPairing Failed with %s. Show Error Popup", remote_dev_info->name);
_bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE,
- remote_dev_info->name, NULL, NULL, NULL);
+ remote_dev_info->name, auth_info, NULL, NULL, NULL);
_bt_free_device_info(remote_dev_info);
g_free(address);
event,
param);
g_free(address);
+ } else if (strcasecmp(property, "TrustedProfiles") == 0) {
+ int trusted = 0;
+
+ g_variant_get(val, "u", &trusted);
+
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ _bt_convert_device_path_to_address(path, address);
+
+ BT_DBG("Address: %s, TrustedProfiles: %d", address, trusted);
+ _bt_send_event(BT_DEVICE_EVENT,
+ BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
+ g_variant_new("(isi)", result, address, trusted));
+ g_free(address);
} else if (strcasecmp(property, "IpspConnected") == 0) {
gboolean connected = FALSE;
event = connected ? BLUETOOTH_EVENT_IPSP_CONNECTED :
- BLUETOOTH_EVENT_IPSP_DISCONNECTED;
+ BLUETOOTH_EVENT_IPSP_DISCONNECTED;
address = g_malloc0(BT_ADDRESS_STRING_SIZE);
/* Send event to application */
_bt_send_event(BT_DEVICE_EVENT,
- BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO,
+ BLUETOOTH_EVENT_IPSP_INTERFACE_INFO,
param);
g_free(address);
}
BT_DBG("-");
}
+int get_alert_level_enum(const char *alert)
+{
+ int lvl = -1;
+
+ if (strcmp(alert, "none") == 0)
+ lvl = BT_PXP_ALERT_NONE;
+ else if (strcmp(alert, "mild") == 0)
+ lvl = BT_PXP_ALERT_MILD;
+ else if (strcmp(alert, "high") == 0)
+ lvl = BT_PXP_ALERT_HIGH;
+
+ return lvl;
+}
+
+static void _bt_handle_pxp_property_changed_event(GVariant *msg, const char *path, int role)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ int service_type;
+ int alert_lvl;
+ GVariantIter value_iter;
+ char *property = NULL;
+ char *address;
+ GVariant *val = NULL;
+ GVariant *child = NULL;
+ GVariant *param = NULL;
+ g_variant_iter_init(&value_iter, msg);
+
+ BT_DBG("+");
+ while ((child = g_variant_iter_next_value(&value_iter))) {
+ g_variant_get(child, "{sv}", &property, &val);
+ BT_INFO("Property %s", property);
+
+ if ((strcasecmp(property, "LinkLossAlertLevel") == 0) ||
+ (strcasecmp(property, "ImmediateAlertLevel") == 0)) {
+ char *alert_str = NULL;
+
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ _bt_convert_device_path_to_address(path, address);
+
+ if (strcasecmp(property, "LinkLossAlertLevel") == 0)
+ service_type = BT_PXP_PROPERTY_LLS;
+ else
+ service_type = BT_PXP_PROPERTY_IAS;
+
+ g_variant_get(val, "s", &alert_str);
+ alert_lvl = get_alert_level_enum(alert_str);
+
+ param = g_variant_new("(isiii)", result, address,
+ role, service_type, alert_lvl);
+
+ /* Send event to application */
+ _bt_send_event(BT_DEVICE_EVENT,
+ BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
+ param);
+ g_free(address);
+ g_free(alert_str);
+ }
+ g_free(property);
+ g_variant_unref(child);
+ g_variant_unref(val);
+ }
+ BT_DBG("-");
+}
+
void _bt_handle_property_changed_event(GVariant *msg, const char *object_path)
{
char *interface_name = NULL;
} else if (strcasecmp(interface_name, BT_GATT_CHAR_INTERFACE) == 0) {
__bt_gatt_char_property_changed_event(val,
object_path);
+ } else if (strcasecmp(interface_name, BT_PROXIMITY_REPORTER_INTERFACE) == 0) {
+ BT_DBG("BT_PROXIMITY_REPORTER_INTERFACE");
+ _bt_handle_pxp_property_changed_event(val,
+ object_path, BT_PXP_REPORTER_ROLE);
+ } else if (strcasecmp(interface_name, BT_PROXIMITY_MONITOR_INTERFACE) == 0) {
+ BT_DBG("BT_PROXIMITY_MONITOR_INTERFACE");
+ _bt_handle_pxp_property_changed_event(val,
+ object_path, BT_PXP_MONITOR_ROLE);
}
g_variant_unref(val);
}
g_variant_get(val, "s", &status);
BT_DBG("Status is %s", status);
- if (strcasecmp(status, "active") == 0) {
+ if (strcasecmp(status, "active") == 0)
_bt_obex_client_started(path);
- } else if (strcasecmp(status, "complete") == 0) {
+ else if (strcasecmp(status, "complete") == 0)
_bt_obex_client_completed(path, TRUE);
- } else if (strcasecmp(status, "error") == 0) {
+ else if (strcasecmp(status, "error") == 0)
_bt_obex_client_completed(path, FALSE);
- }
+
g_free(status);
} else if (strcasecmp(property, "Transferred") == 0) {
- static int transferred = 0;
+ guint64 transferred = 0;
g_variant_get(val, "t", &transferred);
_bt_obex_client_progress(path, transferred);
_bt_send_event(BT_HID_EVENT, event,
param);
/* Check HID connection type (Keyboard or Mouse) and update the status */
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (property_flag == TRUE) {
hid_connected_device_count++;
BT_DBG("HID device class [%x]", remote_dev_info->class);
if (remote_dev_info->class &
BLUETOOTH_DEVICE_MINOR_CLASS_KEY_BOARD) {
-#ifdef ENABLE_TIZEN_2_4
__bt_set_device_values(property_flag,
VCONFKEY_BT_DEVICE_HID_KEYBOARD_CONNECTED);
-#endif
}
if (remote_dev_info->class &
BLUETOOTH_DEVICE_MINOR_CLASS_POINTING_DEVICE) {
-#ifdef ENABLE_TIZEN_2_4
__bt_set_device_values(property_flag,
VCONFKEY_BT_DEVICE_HID_MOUSE_CONNECTED);
-#endif
}
_bt_free_device_info(remote_dev_info);
}
int event = 0;
int result = BLUETOOTH_ERROR_NONE;
char *address;
- char *dev_name;
+ char *dev_name = NULL;
const char *property = NULL;
GVariant *param = NULL;
+ char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
ret_if(path == NULL);
if (strcasecmp(member, "PropertyChanged") == 0) {
_bt_convert_device_path_to_address(path, address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info == NULL) {
g_free(address);
return;
_bt_convert_device_path_to_address(path, address);
- remote_dev_info = _bt_get_remote_device_info(address);
+ remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
if (remote_dev_info == NULL) {
g_free(address);
return;
_bt_convert_device_path_to_address(path, address);
dev_name = _bt_get_bonded_device_name(address);
- BT_INFO("Address : %s Type : %d", address, addr_type);
- BT_ERR_C("Connected [%s] [%s]", !addr_type ? "BREDR" : "LE",
- !addr_type ? dev_name : address);
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+ BT_INFO("Address : %s Type : %d", secure_address, addr_type);
+ BT_ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE",
+ !addr_type ? dev_name : secure_address);
g_free(dev_name);
_bt_logging_connection(TRUE, addr_type);
-#ifdef ENABLE_TIZEN_2_4
- journal_bt_connected();
-#endif
param = g_variant_new("(isy)", result, address, addr_type);
/*Send event to application*/
_bt_send_event(BT_DEVICE_EVENT,
} else if (strcasecmp(member, "Disconnected") == 0) {
unsigned char disc_reason = 0;
unsigned char addr_type = 0;
+ char *dev_name = NULL;
gboolean sending = FALSE;
- g_variant_get(msg, "(yy)", &addr_type, &disc_reason);
+ g_variant_get(msg, "(yys)", &addr_type, &disc_reason, &dev_name);
result = disc_reason;
ret_if(address == NULL);
_bt_convert_device_path_to_address(path, address);
- dev_name = _bt_get_bonded_device_name(address);
-#ifdef ENABLE_TIZEN_2_4
- journal_bt_disconnected();
-#endif
/* 0x00 BDADDR_BRDER
0x01 BDADDR_LE_PUBLIC
0x02 BDADDR_LE_RANDOM */
- BT_INFO("Address : %s Type : %d", address, addr_type);
- BT_ERR_C("Disconnected [%s] [%d : %s] [%s]", !addr_type ? "BREDR" : "LE",
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+ BT_INFO("Address : %s Type : %d", secure_address, addr_type);
+ BT_ERR_C("### Disconnected [%s] [%d : %s] [%s]", !addr_type ? "BREDR" : "LE",
disc_reason, _bt_convert_disc_reason_to_string(disc_reason),
- !addr_type ? dev_name : address);
+ !addr_type ? dev_name : secure_address);
g_free(dev_name);
_bt_headset_set_local_connection(FALSE);
_bt_logging_connection(FALSE, addr_type);
- /*Check for any OPP transfer on the device and cancel
- * the transfer
- */
- _bt_obex_check_pending_transfer(address);
- _bt_opp_client_is_sending(&sending);
- if (sending == TRUE)
- _bt_opp_client_check_pending_transfer(address);
+ if (!addr_type) {
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+ {
+ int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
+
+ if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
+ BT_ERR("vconf_get_int failed");
+
+ BT_INFO("conn_state[0x%x], adapter_state [%d]",
+ bt_device_state, _bt_adapter_get_status());
+
+ if (disc_reason == BLUETOOTH_ERROR_CONNECTION_TIMEOUT) {
+ _bt_audio_start_auto_connect(TRUE);
+ } else if (bt_device_state &
+ VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED) {
+ BT_INFO("Disconnected due to turning BT off. Skip a address");
+ } else {
+ char *last_connected = NULL;
+ last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
+ if (!g_strcmp0(address, last_connected))
+ _bt_audio_set_auto_connect_device_addr("");
+ if (last_connected)
+ free(last_connected);
+ }
+ }
+
+#endif
+ /*Check for any OPP transfer on the device and cancel
+ * the transfer
+ */
+ _bt_obex_check_pending_transfer(address);
+ _bt_opp_client_is_sending(&sending);
+ if (sending == TRUE)
+ _bt_opp_client_check_pending_transfer(address);
+ }
param = g_variant_new("(isy)", result, address, addr_type);
_bt_send_event(BT_DEVICE_EVENT,
BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
int state = 0;
char *profile_uuid = NULL;
bt_headset_wait_t *wait_list;
+ bluetooth_device_address_t bd_addr;
g_variant_get(msg, "(si)", &profile_uuid, &state);
ret_if(address == NULL);
_bt_convert_device_path_to_address(path, address);
+ _bt_convert_addr_string_to_type(bd_addr.addr, address);
- BT_DBG("Address: %s", address);
+ _bt_convert_addr_string_to_secure_string(secure_address, address);
+ BT_DBG("Address: %s", secure_address);
BT_DBG("Profile UUID: %s", profile_uuid);
BT_DBG("State: %d", state);
bluetooth_device_address_t device_address;
gboolean connected;
bt_headset_wait_t *wait_list;
+ guint restricted = 0x0;
__bt_set_device_values(TRUE,
VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
__bt_connection_manager_set_state(address, event);
- if (_bt_headset_get_local_connection() == FALSE)
- _bt_start_timer_for_connection(address, BT_AUDIO_HSP);
- else {
+ _bt_get_restrict_profile(&bd_addr, RESTRICTED_PROFILE_HFP_HS, &restricted);
+
+ if (_bt_headset_get_local_connection() == FALSE) {
+ if (restricted == 0x0) /* not restricted*/
+ _bt_start_timer_for_connection(address, BT_AUDIO_HSP);
+ } else {
/* Connection Started from local device therefore no need to
* intiate connection for pending profile */
_bt_headset_set_local_connection(FALSE);
_bt_audio_connect(wait_list->req_id,
wait_list->type,
&device_address,
- wait_list->out_param1);
+ NULL);
}
} else if (strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0) {
if (state == BT_PROFILE_STATE_CONNECTED) {
int event = BLUETOOTH_EVENT_AV_SOURCE_CONNECTED;
BT_INFO("A2DP Source is connected");
+#ifdef TIZEN_BT_A2DP_SINK_ENABLE
+ __bt_set_device_values(TRUE,
+ VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED);
+#endif
+
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+ _bt_audio_set_auto_connect_device_addr(address);
+ _bt_audio_stop_auto_connect();
+#endif
+ _bt_add_headset_to_list(BT_AUDIO_A2DP_SOURCE,
+ BT_STATE_CONNECTED, address);
_bt_send_event(BT_A2DP_SOURCE_EVENT, event,
g_variant_new("(is)", result, address));
} else if (state == BT_PROFILE_STATE_DISCONNECTED) {
int event = BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED;
BT_INFO("A2DP Source Disconnected");
+#ifdef TIZEN_BT_A2DP_SINK_ENABLE
+ __bt_set_device_values(FALSE,
+ VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED);
+#endif
+ _bt_remove_headset_from_list(BT_AUDIO_A2DP_SOURCE, address);
_bt_send_event(BT_A2DP_SOURCE_EVENT, event,
g_variant_new("(is)", result, address));
+
+ wait_list = _bt_get_audio_wait_data();
+ if (wait_list && wait_list->type == BT_AUDIO_A2DP_SOURCE) {
+ bluetooth_device_address_t device_address;
+ _bt_convert_addr_string_to_type(
+ device_address.addr,
+ wait_list->address);
+
+ _bt_audio_connect(wait_list->req_id,
+ wait_list->type,
+ &device_address,
+ NULL);
+ /* Now free the wait list */
+ _bt_rel_wait_data();
+ }
}
} else if ((strcmp(profile_uuid, HID_UUID) == 0) &&
((state == BT_PROFILE_STATE_CONNECTED) ||
param = g_variant_new("(is)", result, address);
_bt_send_event(BT_HID_EVENT, event,
param);
-
- if (state == BT_PROFILE_STATE_CONNECTED)
- __bt_set_device_values(TRUE,
- VCONFKEY_BT_DEVICE_HID_CONNECTED);
- else
- __bt_set_device_values(FALSE,
- VCONFKEY_BT_DEVICE_HID_CONNECTED);
+ } else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) {
+ if (state == BT_PROFILE_STATE_CONNECTED) {
+ int event;
+ event = BLUETOOTH_HID_DEVICE_CONNECTED;
+ param = g_variant_new("(is)", result, address);
+ _bt_send_event(BT_HID_DEVICE_EVENT, event,
+ param);
+ } else if (state == BT_PROFILE_STATE_DISCONNECTED) {
+ event = BLUETOOTH_HID_DEVICE_DISCONNECTED;
+ param = g_variant_new("(is)", result, address);
+ _bt_send_event(BT_HID_DEVICE_EVENT, event,
+ param);
+ }
}
g_free(address);
g_free(profile_uuid);
&le_dev_info->rssi,
&le_dev_info->adv_data_len,
&value);
+ _bt_convert_device_path_to_address(path, le_dev_info->address);
+
buffer_len = g_variant_get_size(value);
if (buffer_len > 0)
buffer = (char *)g_variant_get_data(value);
}
adv_info->addr = g_strdup(le_dev_info->address);
+ adv_info->addr_type = le_dev_info->addr_type;
+ adv_info->rssi = le_dev_info->rssi;
adv_info->data_len = le_dev_info->adv_data_len;
adv_info->data = g_malloc0(le_dev_info->adv_data_len);
if (adv_info->data) {
memcpy(adv_info->data, le_dev_info->adv_data,
le_dev_info->adv_data_len);
-
- __bt_add_adv_ind_info(adv_info);
}
+ if (__bt_add_adv_ind_info(adv_info) == 0) {
+ adv_info->timer_id = g_timeout_add(1000,
+ (GSourceFunc)__bt_adv_scan_req_timeout_cb, (void*)adv_info);
+ }
} else { /* SCAN_RSP */
adv_info = __bt_get_adv_ind_info(le_dev_info->address);
if (adv_info) {
_bt_free_le_device_info(le_dev_info);
g_variant_unref(value);
} else if (strcasecmp(member, "LEDataLengthChanged") == 0) {
- int tx_octets = 0;
- int tx_time = 0;
- int rx_octets = 0;
- int rx_time = 0;
+ guint16 tx_octets = 0;
+ guint16 tx_time = 0;
+ guint16 rx_octets = 0;
+ guint16 rx_time = 0;
g_variant_get(msg, "(qqqq)",
- tx_octets, tx_time, rx_octets, rx_time);
+ &tx_octets, &tx_time, &rx_octets, &rx_time);
address = g_malloc0(BT_ADDRESS_STRING_SIZE);
_bt_convert_device_path_to_address(path, address);
param = g_variant_new("(isqqqq)", result, address, tx_octets, tx_time,
rx_octets, rx_time);
/* Send event to application */
- _bt_send_event(BT_DEVICE_EVENT, event, param);
+ _bt_send_event(BT_DEVICE_EVENT,
+ BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED, param);
g_free(address);
- }
+ } else if (strcasecmp(member, "IpspStateChanged") == 0) {
+ gboolean connected = FALSE;
+ char *ifname = NULL;
+
+ g_variant_get(msg, "(bs)", &connected, &ifname);
+
+ event = connected ? BLUETOOTH_EVENT_IPSP_CONNECTED :
+ BLUETOOTH_EVENT_IPSP_DISCONNECTED;
+ address = g_malloc0(BT_ADDRESS_STRING_SIZE);
+ _bt_convert_device_path_to_address(path, address);
+
+ BT_DBG("Ipsp BT Interface Name: %s", ifname);
+ BT_DBG("address: %s", address);
+ param = g_variant_new("(iss)", result, address, ifname);
+
+ /* Send event to application */
+ _bt_send_event(BT_DEVICE_EVENT,
+ event,
+ param);
+ g_free(address);
+ } else if (strcasecmp(member, "iBeaconReport") == 0) {
+ bt_remote_ibeacon_dev_info_t *ibeacon_dev_info = NULL;
+
+ ret_if(_bt_is_le_scanning() == FALSE);
+
+ ibeacon_dev_info = g_malloc0(sizeof(bt_remote_ibeacon_dev_info_t));
+ if (ibeacon_dev_info == NULL)
+ return;
+
+ g_variant_get(msg, "(syuusuuy)", &ibeacon_dev_info->address,
+ &ibeacon_dev_info->addr_type,
+ &ibeacon_dev_info->company_id,
+ &ibeacon_dev_info->ibeacon_type,
+ &ibeacon_dev_info->uuid,
+ &ibeacon_dev_info->major_id,
+ &ibeacon_dev_info->minor_id,
+ &ibeacon_dev_info->measured_power);
+ _bt_send_ibeacon_scan_result_event(ibeacon_dev_info);
+ g_free(ibeacon_dev_info);
+ }
}
void __bt_set_audio_values(gboolean connected, char *address)
int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
/* Set the headset name */
- if (connected == TRUE) {
+ if (connected == TRUE)
name = _bt_get_bonded_device_name(address);
- } else {
+ else
name = g_strdup("");
- }
- if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME,
- name) != 0) {
+ if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME, name) != 0)
BT_ERR("vconf_set_str failed");
- }
g_free(name);
/* Set the headset state */
- if (vconf_get_int(VCONFKEY_BT_DEVICE,
- &bt_device_state) != 0) {
- BT_ERR("vconf_get_str failed");
- }
+ if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
+ BT_ERR("vconf_get_int failed");
#ifdef TIZEN_SUPPORT_DUAL_HF
if ((connected == TRUE) &&
bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
}
#else
- if (connected == TRUE) {
+ if (connected == TRUE)
bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
- } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) {
+ else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED)
bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
- }
#endif
if (vconf_set_int(VCONFKEY_BT_DEVICE,
GVariant *value = NULL;
GVariant *param = NULL;
g_variant_get(msg, "(sv)", &property, &value);
+ bluetooth_device_address_t bd_addr;
ret_if(property == NULL);
int event = BLUETOOTH_EVENT_NONE;
bt_headset_wait_t *wait_list;
char *address;
+ guint restricted = 0x0;
g_variant_get(value, "b", &property_flag);
address = g_malloc0(BT_ADDRESS_STRING_SIZE);
-
- /* Fix : NULL_RETURNS */
if (address == NULL)
return;
_bt_convert_device_path_to_address(path, address);
+ _bt_convert_addr_string_to_type(bd_addr.addr, address);
if (property_flag == TRUE) {
event = BLUETOOTH_EVENT_AG_CONNECTED;
- if (_bt_headset_get_local_connection() == FALSE)
- _bt_start_timer_for_connection(address, BT_AUDIO_A2DP);
- else
+ _bt_get_restrict_profile(&bd_addr, RESTRICTED_PROFILE_A2DP, &restricted);
+
+ if (_bt_headset_get_local_connection() == FALSE) {
+ if (restricted == 0x0) /* not restricted*/
+ _bt_start_timer_for_connection(address, BT_AUDIO_A2DP);
+ } else
_bt_headset_set_local_connection(FALSE);
} else {
int previous_state;
_bt_convert_addr_string_to_type(device_address.addr,
wait_list->address);
_bt_audio_connect(wait_list->req_id, wait_list->type,
- &device_address, wait_list->out_param1);
+ &device_address, NULL);
_bt_rel_wait_data();
} else if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
/* Add data to the connected list */
_bt_convert_device_path_to_address(path, address);
- g_variant_get(value, "i", &spkr_gain);
- param = g_variant_new("(isq)", result, address, spkr_gain);
+ spkr_gain = g_variant_get_uint16(value);
+
+ BT_DBG("spkr_gain: %d", spkr_gain);
+
+ param = g_variant_new("(i&sq)", result, address, spkr_gain);
_bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
param);
_bt_convert_device_path_to_address(path, address);
- g_variant_get(value, "i", &mic_gain);
- param = g_variant_new("(isq)", result, address, mic_gain);
+ mic_gain = g_variant_get_uint16(value);
+
+ param = g_variant_new("(i&sq)", result, address, mic_gain);
_bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
param);
g_free(address);
if (property)
g_free(property);
g_variant_unref(value);
- }
+}
void _bt_handle_sink_event(GVariant *msg, const char *path)
{
_bt_audio_connect(wait_list->req_id,
wait_list->type,
&device_address,
- wait_list->out_param1);
+ NULL);
}
g_free(address);
} else if (strcasecmp(value, "Connected") == 0) {
BT_DBG("InterfacesRemoved");
_bt_handle_adapter_removed();
#endif
- if (g_strcmp0(interface_name, BT_MEDIATRANSPORT_INTERFACE) == 0) {
+ if (g_strcmp0(interface_name, BT_MEDIATRANSPORT_INTERFACE) == 0)
bt_event = BT_MEDIA_TRANSFER_EVENT;
- } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
+ else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0)
bt_event = BT_DEVICE_EVENT;
- } else if (g_strcmp0(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0) {
+ else if (g_strcmp0(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0)
bt_event = BT_AVRCP_CONTROL_EVENT;
- }
+
if ((bt_event != 0) && (bt_event != BT_MEDIA_TRANSFER_EVENT)) {
_bt_handle_adapter_event(parameters, signal_name);
if (bt_event == BT_AVRCP_CONTROL_EVENT) {
if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
BT_DBG("Bluetoothd is terminated");
if (_bt_adapter_get_status() == BT_ACTIVATED)
- __bt_disable_cb();
+ _bt_disable_cb();
_bt_handle_adapter_removed();
__bt_devices_list_free();
BT_ERR("Fail to get the path");
return;
}
- BT_INFO("object_path = [%s]", object_path);
+ BT_INFO("object_path = [%s]", obj_path);
/*Handle OPP_SERVER_CONNECTED_EVENT here */
if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
BT_DBG("Obex_Server_Session_Transfer connected");
- _bt_obex_transfer_connected();
+ _bt_obex_transfer_connected(obj_path);
}
g_free(obj_path);
} else if (strcasecmp(member, "InterfacesRemoved") == 0) {
BT_ERR("Fail to get the path");
return;
}
- BT_INFO("object_path = [%s]", object_path);
+ BT_INFO("object_path = [%s]", obj_path);
if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
}
if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
- BT_DBG("Obex_Server_Session_Transfer disconnected");
- _bt_obex_transfer_disconnected();
+ BT_DBG("Obex_Server_Session_Transfer disconnected %s",
+ obj_path);
+
+ _bt_obex_transfer_disconnected(obj_path);
}
g_free(obj_path);
} else if (__bt_is_obexd_event(parameters, interface_name) == TRUE) {
return 0;
}
+static void __bt_dump_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)
+{
+ return;
+}
+
+int __bt_register_dump_subscribe_signal(GDBusConnection *conn,
+ gboolean subscribe)
+{
+ if (conn == NULL)
+ return -1;
+
+ static int subs_source_id = -1;
+
+ if (subscribe) {
+ if (subs_source_id == -1) {
+ subs_source_id = g_dbus_connection_signal_subscribe(conn,
+ NULL, BT_DUMP_SERVICE_INTERFACE,
+ BT_DUMP_SERVICE_SIGNAL, BT_DUMP_SERVICE_PATH, NULL, 0,
+ __bt_dump_event_filter,
+ NULL, NULL);
+ }
+ } else {
+ if (subs_source_id != -1) {
+ g_dbus_connection_signal_unsubscribe(conn,
+ subs_source_id);
+ subs_source_id = -1;
+ }
+ }
+ return 0;
+}
+
int _bt_register_service_event(GDBusConnection *g_conn, int event_type)
{
BT_DBG("+");
if (_bt_register_service_event(manager_conn,
BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
goto fail;
+
+ __bt_register_dump_subscribe_signal(manager_conn, TRUE);
return BLUETOOTH_ERROR_NONE;
fail:
if (manager_conn) {
return BLUETOOTH_ERROR_NONE;
}
+gboolean __bt_reinit_obexd_receiver(gpointer user_data)
+{
+ static int retry_cnt = 0;
+ int result = BLUETOOTH_ERROR_NONE;
+
+ BT_DBG("+");
+
+ result = __bt_init_obexd_receiver();
+ if (result != BLUETOOTH_ERROR_NONE) {
+ /* 20 ms * 50 = 10 seconds. During 10 seconds fail to initialize,
+ then it is not the timing issue. Just can't use the session bus connection */
+ if (retry_cnt > 100) {
+ BT_ERR("Fail to init obexd receiver by 50 times.");
+ retry_cnt = 0;
+ session_reinit_timer = 0;
+ return FALSE;
+ }
+ retry_cnt++;
+ BT_DBG("Retry to initialize the obexd receiver");
+ return TRUE;
+ }
+
+ retry_cnt = 0;
+ session_reinit_timer = 0;
+
+ BT_DBG("-");
+
+ return FALSE;
+}
+
/* To receive the event from bluez */
int _bt_init_service_event_receiver(void)
{
retv_if(result != BLUETOOTH_ERROR_NONE, result);
result = __bt_init_obexd_receiver();
- if (result != BLUETOOTH_ERROR_NONE)
+ if (result != BLUETOOTH_ERROR_NONE) {
BT_ERR("Fail to init obexd receiver");
+ /* Try to re-initialize obexd receiver in the timer */
+ if (session_reinit_timer > 0)
+ g_source_remove(session_reinit_timer);
+
+ session_reinit_timer = g_timeout_add(BT_SESSION_BUS_GET_TIMEOUT,
+ (GSourceFunc)__bt_reinit_obexd_receiver, NULL);
+ }
+
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
_bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
+ __bt_register_dump_subscribe_signal(manager_conn, FALSE);
+
if (manager_conn) {
g_object_unref(manager_conn);
manager_conn = NULL;
if (event_id > 0)
g_source_remove(event_id);
+ event_id = 0;
BT_DBG("-");
}
int _bt_send_event(int event_type, int event, GVariant *param)
{
- BT_DBG("+");
char *path;
char *signal;
GDBusMessage *msg1 = NULL;
case BT_HID_EVENT:
path = BT_HID_PATH;
break;
+ case BT_HID_DEVICE_EVENT:
+ path = BT_HID_DEVICE_PATH;
+ break;
case BT_HEADSET_EVENT:
path = BT_HEADSET_PATH;
break;
case BT_RFCOMM_SERVER_EVENT:
path = BT_RFCOMM_SERVER_PATH;
break;
- case BT_A2DP_SOURCE_EVENT:
- path = BT_A2DP_SOURCE_PATH;
- break;
+ case BT_A2DP_SOURCE_EVENT:
+ path = BT_A2DP_SOURCE_PATH;
+ break;
default:
BT_ERR("Unknown event");
return BLUETOOTH_ERROR_INTERNAL;
switch (event) {
case BLUETOOTH_EVENT_ENABLED:
signal = BT_ENABLED;
+ BT_INFO_C("### BT Enabled");
break;
case BLUETOOTH_EVENT_DISABLED:
signal = BT_DISABLED;
+ BT_INFO_C("### BT Disabled");
break;
case BLUETOOTH_EVENT_LE_ENABLED:
signal = BT_LE_ENABLED;
case BLUETOOTH_EVENT_RAW_RSSI:
signal = BT_RAW_RSSI_EVENT;
break;
+ case BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED:
+ signal = BT_SUPPORTED_PROFILE_TRUSTED;
+ break;
case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
signal = BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED;
break;
signal = BT_INPUT_DISCONNECTED;
BT_INFO_C("Disconnected [HID]");
break;
+ case BLUETOOTH_HID_DEVICE_CONNECTED:
+ signal = BT_INPUT_HID_DEVICE_CONNECTED;
+ BT_INFO_C("Connected [HIDDevice]");
+ break;
+ case BLUETOOTH_HID_DEVICE_DISCONNECTED:
+ signal = BT_INPUT_HID_DEVICE_DISCONNECTED;
+ BT_INFO_C("Disconnected [HIDDevice]");
+ break;
case BLUETOOTH_PBAP_CONNECTED:
signal = BT_PBAP_CONNECTED;
BT_INFO_C("Connected [PBAP Client]");
signal = BT_STEREO_HEADSET_DISCONNECTED;
BT_INFO_C("Disconnected [A2DP]");
break;
+ case BLUETOOTH_EVENT_AV_SOURCE_CONNECTED:
+ signal = BT_A2DP_SOURCE_CONNECTED;
+ BT_INFO_C("Connected [A2DP Source]");
+ break;
+ case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
+ signal = BT_A2DP_SOURCE_DISCONNECTED;
+ BT_INFO_C("Disconnected [A2DP Source]");
+ break;
case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
signal = BT_SCO_CONNECTED;
BT_INFO_C("Connected [SCO]");
case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
signal = BT_DEVICE_DISCONNECTED;
break;
- case BLUETOOTH_EVENT_AV_SOURCE_CONNECTED:
- signal = BT_A2DP_SOURCE_CONNECTED;
- BT_INFO_C("Connected [A2DP Source]");
- break;
- case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
- signal = BT_A2DP_SOURCE_DISCONNECTED;
- BT_INFO_C("Disconnected [A2DP Source]");
- break;
case BLUETOOTH_EVENT_AVRCP_CONNECTED:
case BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED:
signal = BT_AVRCP_CONNECTED;
break;
case BLUETOOTH_EVENT_GATT_CONNECTED:
signal = BT_GATT_CONNECTED;
+ BT_INFO_C("### Connected [GATT]");
break;
case BLUETOOTH_EVENT_GATT_DISCONNECTED:
signal = BT_GATT_DISCONNECTED;
+ BT_INFO_C("### Disconnected [GATT]");
+ break;
+ case BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED:
+ signal = BT_GATT_REQ_ATT_MTU_CHANGED;
break;
case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED:
signal = BT_IPSP_INITIALIZED;
case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
signal = BT_IPSP_DISCONNECTED;
break;
- case BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO:
- signal = BT_IPSP_BT_INTERFACE_INFO;
- break;
case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
signal = BT_GATT_CHAR_VAL_CHANGED;
break;
case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
signal = BT_LE_DATA_LENGTH_CHANGED;
break;
+ case BLUETOOTH_EVENT_REMOTE_IBEACON_DEVICE_FOUND:
+ signal = BT_IBEACON_DEVICE_FOUND;
+ break;
+ case BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED:
+ signal = BT_PXP_PROPERTY_CHANGED;
+ break;
default:
BT_ERR("Unknown event");
return BLUETOOTH_ERROR_INTERNAL;
msg1 = g_dbus_message_new_signal(path, BT_EVENT_SERVICE, signal);
g_dbus_message_set_body(msg1, param);
- if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL)) {
+ if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL))
BT_ERR("Error while sending");
- }
g_object_unref(msg1);
int _bt_send_event_to_dest(const char* dest, int event_type,
int event, GVariant *param)
{
- BT_DBG("+");
char *path;
char *signal;
GError *error = NULL;
retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
- BT_DBG("dest : %s", dest);
BT_DBG("event_type [%d], event [%d]", event_type, event);
switch (event_type) {
path = BT_LE_ADAPTER_PATH;
break;
case BT_DEVICE_EVENT:
- path = BT_DEVICE_PATH;
+ path = BT_DEVICE_PATH;
break;
default:
BT_ERR("Unknown event");
case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
signal = BT_ADVERTISING_STOPPED;
break;
+ case BLUETOOTH_EVENT_PASSKEY_NOTIFICATION:
+ signal = BT_PASSKEY_NOTIFICATION;
+ break;
case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
signal = BT_LE_DISCOVERY_STARTED;
break;
return BLUETOOTH_ERROR_INTERNAL;
}
- BT_DBG("Path : %s", path);
BT_INFO_C("Signal : %s", signal);
if (!g_dbus_connection_emit_signal(event_conn, dest, path, BT_EVENT_SERVICE,
}
}
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
hf_local_term_event_conn = NULL;
}
}
+
+int _bt_send_dump_signal(char *signal)
+{
+ GError *error = NULL;
+ int32_t pid = getpid();
+
+ retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ if (!g_dbus_connection_emit_signal(event_conn, NULL,
+ BT_DUMP_SERVICE_PATH,
+ BT_DUMP_SERVICE_INTERFACE,
+ signal, g_variant_new("(i)", pid),
+ &error)) {
+ BT_ERR("Error while sending Signal: %s", signal);
+ if (error) {
+ BT_ERR("Error Code [%d], Error Message [%s]",
+ error->code, error->message);
+ g_clear_error(&error);
+ }
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
return FALSE;
server = g_malloc0(sizeof(bt_agent_osp_server_t));
-
- /* Fix : NULL_RETURNS */
retv_if(server == NULL, FALSE);
server->type = type;
BT_DBG("+");
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
retv_if(priv == NULL, FALSE);
if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
BT_DBG("+");
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
retv_if(priv == NULL, FALSE);
if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
BT_DBG("+");
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
retv_if(priv == NULL, FALSE);
if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
BT_DBG("+");
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
retv_if(priv == NULL, FALSE);
if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION &&
if (accept == GAP_AGENT_ACCEPT) {
g_dbus_method_invocation_return_value(priv->reply_context, NULL);
} else if (accept == GAP_AGENT_ACCEPT_ALWAYS) {
- bluetooth_device_address_t addr = { {0,} };
+ bluetooth_device_address_t addr = { { 0, } };
int result;
_bt_convert_addr_string_to_type(addr.addr,
priv->authorize_addr);
- result = _bt_set_authorization(&addr, TRUE);
+ /* Do not set device as Trusted*/
+ /* result = _bt_set_authorization(&addr, TRUE); */
+ result = _bt_set_trust_profile(&addr,
+ _bt_get_trusted_profile_enum(priv->uuid),
+ TRUE);
if (result == BLUETOOTH_ERROR_NONE) {
- BT_INFO("[%s] Device added to trusted", priv->authorize_addr);
+ BT_INFO("[%s] Profile added as trusted for Device[%s]",
+ priv->uuid, priv->authorize_addr);
}
g_dbus_method_invocation_return_value(priv->reply_context, NULL);
GAP_AGENT_ERROR, GAP_AGENT_ERROR_CANCEL,
"CanceledbyUser");
break;
+ case GAP_AGENT_REJECT: {
+ bluetooth_device_address_t addr = { { 0, } };
+ int result;
+
+ _bt_convert_addr_string_to_type(addr.addr,
+ priv->authorize_addr);
+
+ /* Set Profile as blocked */
+ result = _bt_set_trust_profile(&addr,
+ _bt_get_trusted_profile_enum(priv->uuid),
+ FALSE);
+ if (result == BLUETOOTH_ERROR_NONE) {
+ BT_INFO("[%s] Profile added as blocked for Device[%s]",
+ priv->uuid, priv->authorize_addr);
+ }
+
+ g_dbus_method_invocation_return_error(priv->reply_context,
+ GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
+ "Authorization request rejected");
+ break;
+ }
case GAP_AGENT_TIMEOUT:
- case GAP_AGENT_REJECT:
default:
g_dbus_method_invocation_return_error(priv->reply_context,
GAP_AGENT_ERROR, GAP_AGENT_ERROR_REJECT,
ret = FALSE;
}
- priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
- priv->reply_context = NULL;
- memset(priv->authorize_addr, 0x00, sizeof(priv->authorize_addr));
+ if (priv->exec_type != GAP_AGENT_EXEC_NO_OPERATION) {
+ priv->exec_type = GAP_AGENT_EXEC_NO_OPERATION;
+ priv->reply_context = NULL;
+ memset(priv->authorize_addr, 0x00, sizeof(priv->authorize_addr));
+ g_free(priv->uuid);
+ priv->uuid = NULL;
+ }
BT_DBG("-");
reply = g_dbus_proxy_call_sync(agent_manager, "RegisterAgent",
#ifdef TIZEN_BT_IO_CAPA_NO_INPUT_OUTPUT
g_variant_new("(os)", priv->path, "NoInputNoOutput"),
+#elif defined(TIZEN_BT_IO_CAPA_DISPLAY_ONLY)
+ g_variant_new("(os)", priv->path, "DisplayOnly"),
#else
- g_variant_new("(os)", priv->path, "DisplayYesNo"),
+ g_variant_new("(os)", priv->path, "KeyboardDisplay"),
#endif
G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &error);
}
reply = g_dbus_proxy_call_sync(agent_manager, "UnregisterAgent",
- g_variant_new("o", priv->path),
+ g_variant_new("(o)", priv->path),
G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &error);
g_object_unref(agent_manager);
static const gchar gap_agent_bluez_introspection_xml[] =
"<node name='/'>"
" <interface name='org.bluez.Agent1'>"
-" <method name='GetDiscoverableTimeout'>"
-" <arg type='u' name='timeout' direction='out'/>"
-" </method>"
-" <method name='Cancel'>"
-" </method>"
-" <method name='RequestPasskey'>"
-" <arg type='o' name='device' direction='in'/>"
-" <arg type='u' name='passkey' direction='out'/>"
-" </method>"
-" <method name='Release'>"
-" </method>"
" <method name='RequestConfirmation'>"
-" <arg type='o' name='device' direction='in'/>"
+" <arg type='o' name='target' direction='in'/>"
" <arg type='u' name='passkey' direction='in'/>"
" </method>"
+" <method name='RequestPinCode'>"
+" <arg type='o' name='target' direction='in'/>"
+" <arg type='s' name='pincode' direction='out'/>"
+" </method>"
" <method name='RequestAuthorization'>"
-" <arg type='o' name='device' direction='in'/>"
+" <arg type='o' name='target' direction='in'/>"
" </method>"
-" <method name='ReplyPasskey'>"
-" <arg type='u' name='accept' direction='in'/>"
-" <arg type='s' name='passkey' direction='in'/>"
+" <method name='RequestPasskey'>"
+" <arg type='o' name='target' direction='in'/>"
+" <arg type='u' name='passkey' direction='out'/>"
+" </method>"
+" <method name='AuthorizeService'>"
+" <arg type='o' name='target' direction='in'/>"
+" <arg type='s' name='uuid' direction='in'/>"
+" </method>"
+" <method name='DisplayPasskey'>"
+" <arg type='o' name='target' direction='in'/>"
+" <arg type='u' name='passkey' direction='in'/>"
+" <arg type='q' name='entered' direction='in'/>"
" </method>"
-" <method name='DisplayPasskey'>"
-" <arg type='o' name='device' direction='in'/>"
-" <arg type='u' name='passkey' direction='in'/>"
-" <arg type='q' name='entered' direction='in'/>"
+" <method name='ReplyConfirmation'>"
+" <arg type='u' name='accept' direction='in'/>"
" </method>"
-" <method name='ReplyConfirmation'>"
+" <method name='ReplyPinCode'>"
" <arg type='u' name='accept' direction='in'/>"
+" <arg type='s' name='pincode' direction='in'/>"
" </method>"
-" <method name='ReplyPinCode'>"
+" <method name='ReplyAuthorize'>"
" <arg type='u' name='accept' direction='in'/>"
-" <arg type='s' name='pincode' direction='in'/>"
" </method>"
-" <method name='ReplyAuthorize'>"
+" <method name='ReplyPasskey'>"
" <arg type='u' name='accept' direction='in'/>"
+" <arg type='s' name='passkey' direction='in'/>"
" </method>"
-" <method name='RequestPinCode'>"
-" <arg type='o' name='device' direction='in'/>"
-" <arg type='s' name='pincode' direction='out'/>"
+" <method name='GetDiscoverableTimeout'>"
+" <arg type='u' name='timeout' direction='out'/>"
" </method>"
" <method name='ConfirmModeChange'>"
" <arg type='s' name='mode' direction='in'/>"
" </method>"
-" <method name='AuthorizeService'>"
-" <arg type='o' name='device' direction='in'/>"
-" <arg type='s' name='uuid' direction='in'/>"
+" <method name='Cancel'>"
+" </method>"
+" <method name='Release'>"
" </method>"
" </interface>"
"</node>";
if (!agent->cb.passkey_func)
return;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL)
return;
addr += 4;
g_strlcpy(agent->pairing_addr, addr, sizeof(agent->pairing_addr));
- while ((pos = strchr(agent->pairing_addr, '_')) != NULL) {
+ while ((pos = strchr(agent->pairing_addr, '_')) != NULL)
*pos = ':';
- }
}
agent->cb.pincode_func(agent, device);
if (!priv->cb.passkey_func)
return;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL)
return;
addr += 4;
g_strlcpy(priv->pairing_addr, addr, sizeof(priv->pairing_addr));
- while ((pos = strchr(priv->pairing_addr, '_')) != NULL) {
+ while ((pos = strchr(priv->pairing_addr, '_')) != NULL)
*pos = ':';
- }
}
priv->cb.passkey_func(priv, device);
g_variant_get(parameters, "(&ouq)", &path, &passkey, &entered);
BT_INFO("Request passkey display :sender %s priv->busname %s"
- " Device Path :%s, Passkey: %d, Entered: %d",
+ " Device Path :%s, Passkey: %06d, Entered: %d",
sender, priv->busname, path, passkey, entered);
/* Do not show popup for Key event while typing*/
if (!priv->cb.display_func)
return;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL)
return;
return;
g_variant_get(parameters, "(&ou)", &path, &passkey);
- BT_INFO("Request passkey confirmation, Device Path :%s, Passkey: %d",
- path, passkey);
+ BT_INFO_C("### Request passkey confirmation");
+ INFO_SECURE("Device Path :%s, Passkey: %d", path, passkey);
BT_DBG("Sender: [%s] priv->busname: [%s]", sender, priv->busname);
/* Need to check
if (!priv->cb.confirm_func)
return;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL)
return;
addr += 4;
g_strlcpy(priv->pairing_addr, addr, sizeof(priv->pairing_addr));
- while ((pos = strchr(priv->pairing_addr, '_')) != NULL) {
+ while ((pos = strchr(priv->pairing_addr, '_')) != NULL)
*pos = ':';
- }
}
priv->cb.confirm_func(priv, device, passkey);
if (!priv->cb.authorize_func)
return;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
if (conn == NULL)
return;
priv->exec_type = GAP_AGENT_EXEC_AUTHORZATION;
priv->reply_context = invocation;
+ priv->uuid = g_strdup(uuid);
addr = strstr(path, "dev_");
if (addr != NULL) {
g_strlcpy(priv->authorize_addr, addr,
sizeof(priv->authorize_addr));
- while ((pos = strchr(priv->authorize_addr, '_')) != NULL) {
+ while ((pos = strchr(priv->authorize_addr, '_')) != NULL)
*pos = ':';
- }
}
priv->cb.authorize_func(priv, device, uuid);
GDBusNodeInfo *node_info;
GError *error = NULL;
-
priv->path = g_strdup(path);
BT_DBG("path is [%s]", path);
- connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
- if (!connection) {
- if (error) {
- ERR("Unable to connect to gdbus: %s", error->message);
- g_clear_error(&error);
+ if (connection == NULL) {
+ connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (!connection) {
+ if (error) {
+ ERR("Unable to connect to gdbus: %s", error->message);
+ g_clear_error(&error);
+ }
+ g_dbus_node_info_unref(node_info);
+ return;
}
- g_dbus_node_info_unref(node_info);
- return;
}
if (gap_agent_id == -1) {
void _gap_agent_reset_dbus(GapAgentPrivate *agent)
{
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
if (priv == NULL)
- return ;
+ return;
__gap_agent_unregister(agent);
if (gap_agent_id > 0) {
g_dbus_connection_unregister_object(connection,
gap_agent_id);
- gap_agent_id = 0;
+ gap_agent_id = -1;
+ }
+
+ if (connection) {
+ g_object_unref(connection);
+ connection = NULL;
}
if (priv->osp_servers) {
priv->osp_servers = NULL;
}
- g_object_ref(priv->adapter);
- priv->adapter = NULL;
-
g_free(priv->path);
priv->path = NULL;
{
GapAgentPrivate *priv = agent;
- /* Fix : NULL_RETURNS */
- retv_if(priv == NULL, FALSE);
+ if (priv == NULL)
+ return FALSE;
if (__gap_agent_find_server(priv->osp_servers,
type, uuid) != NULL) {
osp_serv = __gap_agent_find_server(priv->osp_servers,
type, uuid);
- if (!osp_serv) {
+ if (!osp_serv)
return NULL;
- }
return osp_serv;
}
gchar* _gap_agent_get_path(GapAgentPrivate *agent)
{
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
if (priv == NULL)
return NULL;
{
GapAgentPrivate *priv = agent;
- /* Fix : NULL_RETURNS */
- retv_if(priv == NULL, FALSE);
-
return priv->canceled;
}
void _gap_agent_set_canceled(GapAgentPrivate *agent, gboolean value)
{
GapAgentPrivate *priv = agent;
-
- /* Fix : NULL_RETURNS */
if (priv == NULL)
return;
<interface name="org.bluez.Agent">
<method name="RequestPinCode">
<annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
- <arg type="o" name="device"/>
+ <arg type="o" name="target"/>
<arg type="s" name="pincode" direction="out"/>
</method>
<method name="RequestPasskey">
<annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
- <arg type="o" name="device"/>
+ <arg type="o" name="target"/>
<arg type="u" name="passkey" direction="out"/>
</method>
<method name="DisplayPasskey">
<annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
- <arg type="o" name="device"/>
+ <arg type="o" name="target"/>
<arg type="u" name="passkey"/>
</method>
<method name="RequestConfirmation">
<annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
- <arg type="o" name="device"/>
+ <arg type="o" name="target"/>
<arg type="u" name="passkey"/>
</method>
<method name="Authorize">
<annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
- <arg type="o" name="device"/>
+ <arg type="o" name="target"/>
<arg type="s" name="uuid"/>
</method>
_bt_convert_addr_type_to_string(remote_address, conn_info->dev_info.device_address.addr);
if (p_connection_list == NULL) {
BT_INFO("None of device connected and this hasbeen triggered");
+ g_free(conn_info);
return FALSE;
}
if (conn_info->connection_type == BT_AUDIO_A2DP) {
if (list == NULL) {
BT_INFO("Head Set didn't initiated a2dp connection");
BT_INFO("local device initiating A2DP connection");
+
_bt_audio_connect(0, BT_AUDIO_A2DP,
&conn_info->dev_info.device_address, NULL);
} else {
if (list == NULL) {
BT_INFO("Headset didn't initiated HFP connection");
BT_INFO("local device intiating HFP Connection");
+
_bt_audio_connect(0, BT_AUDIO_HSP,
&conn_info->dev_info.device_address, NULL);
} else {
int i = 0;
bluetooth_device_info_t info;
char bond_address[BT_ADDRESS_STRING_SIZE] = { 0 };
- dev_list = g_array_new(FALSE, FALSE, sizeof(gchar));
+
if (device == NULL)
return;
+
+ dev_list = g_array_new(FALSE, FALSE, sizeof(gchar));
+
_bt_get_bonded_devices(&dev_list);
size = (dev_list->len) / sizeof(bluetooth_device_info_t);
for (i = 0; i < size; i++) {
void __bt_connection_manager_set_state(char *remote_address, int event)
{
- bt_connection_node_info_t *info = g_new0(bt_connection_node_info_t, 1);
+ bt_connection_node_info_t *info;
char bond_address[BT_ADDRESS_STRING_SIZE] = { 0 };
if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
+ info = g_new0(bt_connection_node_info_t, 1);
info->state = BLUETOOTH_HFP_CONNECTED;
_bt_get_bluetooth_device_info(remote_address, &info->dev_info);
_bt_convert_addr_type_to_string(bond_address,
p_connection_list = g_list_remove(p_connection_list, h_conn);
g_free(h_conn);
} else if (event == BLUETOOTH_EVENT_AV_CONNECTED) {
+ info = g_new0(bt_connection_node_info_t, 1);
info->state = BLUETOOTH_A2DP_CONNECTED;
_bt_get_bluetooth_device_info(remote_address, &info->dev_info);
_bt_convert_addr_type_to_string(bond_address,
#include <gio/gio.h>
#include <dlog.h>
#include <string.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
+#include <vconf.h>
#include "bluetooth-api.h"
#include "bt-service-common.h"
#include "bt-service-event.h"
#include "bt-service-util.h"
+#define BT_HID_BARCODE_SUPPORT "file/bluetooth/hid/barcode_support"
+
static void __bt_hid_connect_cb(GDBusProxy *proxy, GAsyncResult *res,
gpointer user_data)
{
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
*/
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
*/
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
return BLUETOOTH_ERROR_NONE;
}
+
+int _bt_hid_enable_barcode_feature(void)
+{
+ if (vconf_set_int(BT_HID_BARCODE_SUPPORT, 1) != 0) {
+ BT_ERR("Set vconf failed\n");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
static GMainLoop *main_loop;
static gboolean terminated = FALSE;
+static gboolean is_initialized = FALSE;
static void __bt_release_service(void)
{
#ifndef GATT_NO_RELAY
_bt_clear_gatt_client_senders();
#endif
+ is_initialized = FALSE;
_bt_service_cynara_deinit();
BT_DBG("Terminating the bt-service daemon");
gboolean _bt_terminate_service(gpointer user_data)
{
- int bt_status = VCONFKEY_BT_STATUS_OFF;
+ __bt_release_service();
- if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0) {
- BT_ERR("no bluetooth device info, so BT was disabled at previous session");
- } else {
- if (bt_status != VCONFKEY_BT_STATUS_OFF) {
- if (vconf_set_int(VCONFKEY_BT_STATUS,
- VCONFKEY_BT_STATUS_OFF) != 0)
- BT_ERR("Set vconf failed\n");
-
- if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
- EVT_VAL_BT_OFF) != ES_R_OK)
- BT_ERR("Fail to set value");
- }
- }
+ terminated = TRUE;
- if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_status) < 0) {
- BT_ERR("no bluetooth device info, so BT was disabled at previous session");
- } else {
- if (bt_status != VCONFKEY_BT_LE_STATUS_OFF) {
- if (vconf_set_int(VCONFKEY_BT_LE_STATUS,
- VCONFKEY_BT_LE_STATUS_OFF) != 0)
- BT_ERR("Set vconf failed\n");
- if (_bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
- EVT_VAL_BT_LE_OFF) != ES_R_OK)
- BT_ERR("Fail to set value");
- }
- }
+ BT_INFO_C("Terminating the bt-service daemon");
if (main_loop != NULL) {
g_main_loop_quit(main_loop);
} else {
BT_ERR("main_loop == NULL");
- __bt_release_service();
- terminated = TRUE;
exit(0);
}
gboolean _bt_reliable_terminate_service(gpointer user_data)
{
- _bt_deinit_service_event_receiver();
-
_bt_deinit_proxys();
_bt_clear_request_list();
_bt_set_disabled(BLUETOOTH_ERROR_NONE);
- _bt_service_adapter_le_deinit();
_bt_deinit_service_event_sender();
- _bt_deinit_hf_local_term_event_sender();
_bt_service_unregister();
BT_INFO_C("Terminating the bt-service daemon");
- if (main_loop != NULL) {
+ if (main_loop != NULL)
g_main_loop_quit(main_loop);
- } else {
+ else
exit(0);
- }
return FALSE;
}
if (_bt_get_enable_timer_id() == 0)
_bt_enable_adapter();
#else
- if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
BT_DBG("no bluetooth device info, so BT was disabled at previous session");
- }
- if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0) {
+ if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0)
BT_ERR("no bluetooth le info, so BT LE was disabled at previous session");
- }
if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &flight_mode_deactivation) != 0)
BT_ERR("Fail to get the flight_mode_deactivation value");
return FALSE;
}
-int main(void)
+int _bt_service_initialize(void)
{
- struct sigaction sa;
- BT_INFO_C("Starting the bt-service daemon");
+ int ret;
- memset(&sa, 0, sizeof(sa));
- sa.sa_sigaction = __bt_sigterm_handler;
- sa.sa_flags = SA_SIGINFO;
- sigaction(SIGINT, &sa, NULL);
- sigaction(SIGTERM, &sa, NULL);
+ if (is_initialized == TRUE)
+ return BLUETOOTH_ERROR_NONE;
/* Security Initialization */
if (_bt_service_cynara_init() != BLUETOOTH_ERROR_NONE) {
return EXIT_FAILURE;
}
+ _bt_service_register_vconf_handler();
+
/* Event reciever Init */
- if (_bt_init_service_event_receiver() != BLUETOOTH_ERROR_NONE) {
+ ret = _bt_init_service_event_receiver();
+ if (ret != BLUETOOTH_ERROR_NONE) {
BT_ERR("Fail to init event reciever");
- return 0;
+ return ret;
}
/* Event sender Init */
- if (_bt_init_service_event_sender() != BLUETOOTH_ERROR_NONE) {
+ ret = _bt_init_service_event_sender();
+ if (ret != BLUETOOTH_ERROR_NONE) {
BT_ERR("Fail to init event sender");
- return 0;
+ return ret;
}
- if (_bt_init_hf_local_term_event_sender() != BLUETOOTH_ERROR_NONE) {
+ ret = _bt_init_hf_local_term_event_sender();
+ if (ret != BLUETOOTH_ERROR_NONE) {
BT_ERR("Fail to init core event sender");
- return 0;
+ return ret;
}
- if (_bt_service_register() != BLUETOOTH_ERROR_NONE) {
+ ret = _bt_service_register();
+ if (ret != BLUETOOTH_ERROR_NONE) {
BT_ERR("Fail to register service");
- return 0;
+ return ret;
}
- if (_bt_service_adapter_le_init() != BLUETOOTH_ERROR_NONE) {
+ ret = _bt_service_adapter_le_init();
+ if (ret != BLUETOOTH_ERROR_NONE) {
BT_ERR("Fail to init le");
- return 0;
+ return ret;
}
_bt_init_request_id();
_bt_init_gatt_client_senders();
#endif
+ is_initialized = TRUE;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int main(void)
+{
+ struct sigaction sa;
+ BT_INFO_C("### Starting the bt-service daemon");
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_sigaction = __bt_sigterm_handler;
+ sa.sa_flags = SA_SIGINFO;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ if (_bt_service_initialize() != BLUETOOTH_ERROR_NONE)
+ return 0;
+
g_timeout_add(500, (GSourceFunc)__bt_check_bt_service, NULL);
if (terminated == TRUE) {
g_main_loop_run(main_loop);
BT_DBG("g_main_loop_quit called!");
- if (main_loop != NULL) {
+ if (main_loop != NULL)
g_main_loop_unref(main_loop);
- }
if (terminated == FALSE)
__bt_release_service();
#include <dlog.h>
#include <string.h>
#include <stdio.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
#include <net_connection.h>
#include "bluetooth-api.h"
{
int ret = BLUETOOTH_ERROR_NONE;
char *adapter_path;
+ GVariant *result = NULL;
GError *err = NULL;
GDBusConnection *conn;
GDBusProxy *server_proxy;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_path = _bt_get_adapter_path();
return BLUETOOTH_ERROR_INTERNAL;
}
- g_dbus_proxy_call_sync(server_proxy, "Register",
+ result = g_dbus_proxy_call_sync(server_proxy, "Register",
g_variant_new("(ss)", NAP_UUID_NAME, NET_BRIDGE_INTERFACE),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&err);
- if (err != NULL) {
- g_dbus_error_strip_remote_error(err);
- BT_ERR("Network server register Error: %s\n", err->message);
- if (g_strcmp0(err->message, "Already Exists") == 0) {
- ret = BLUETOOTH_ERROR_ALREADY_INITIALIZED;
- } else {
- ret = BLUETOOTH_ERROR_INTERNAL;
+ if (result == NULL) {
+ if (err != NULL) {
+ g_dbus_error_strip_remote_error(err);
+ BT_ERR("Network server register Error: %s\n", err->message);
+ if (g_strcmp0(err->message, "Already Exists") == 0)
+ ret = BLUETOOTH_ERROR_ALREADY_INITIALIZED;
+ else
+ ret = BLUETOOTH_ERROR_INTERNAL;
+
+ g_error_free(err);
}
- g_error_free(err);
+ } else {
+ g_variant_unref(result);
}
+
g_object_unref(server_proxy);
return ret;
int _bt_network_deactivate(void)
{
char *adapter_path;
+ GVariant *result = NULL;
GError *err = NULL;
GDBusConnection *conn;
GDBusProxy *server_proxy;
int ret = BLUETOOTH_ERROR_NONE;
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_path = _bt_get_adapter_path();
return BLUETOOTH_ERROR_INTERNAL;
}
- g_dbus_proxy_call_sync(server_proxy, "Unregister",
+ result = g_dbus_proxy_call_sync(server_proxy, "Unregister",
g_variant_new("(s)", NAP_UUID_NAME),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&err);
- if (err != NULL) {
- g_dbus_error_strip_remote_error(err);
- BT_ERR("Network server unregister Error: %s\n", err->message);
- if (g_strcmp0(err->message,
- "Operation currently not available") == 0) {
- ret = BLUETOOTH_ERROR_ALREADY_DEACTIVATED;
- } else {
- ret = BLUETOOTH_ERROR_INTERNAL;
+ if (result == NULL) {
+ if (err != NULL) {
+ g_dbus_error_strip_remote_error(err);
+ BT_ERR("Network server unregister Error: %s\n", err->message);
+ if (g_strcmp0(err->message,
+ "Operation currently not available") == 0) {
+ ret = BLUETOOTH_ERROR_ALREADY_DEACTIVATED;
+ } else {
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ }
+ g_error_free(err);
}
- g_error_free(err);
+ } else {
+ g_variant_unref(result);
}
+
g_object_unref(server_proxy);
return ret;
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
g_variant_unref(result);
retv_if(profile_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
func_data = g_malloc0(sizeof(bt_function_data_t));
+ retv_if(func_data == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
func_data->address = g_strdup(address);
func_data->req_id = request_id;
adapter_proxy = _bt_get_adapter_proxy();
retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_convert_addr_type_to_string(address, device_address->addr);
device_path = g_variant_get_string(result, NULL);
if (device_path == NULL) {
BT_ERR("No paired device");
+ g_variant_unref(result);
return BLUETOOTH_ERROR_NOT_PAIRED;
}
g_variant_unref(result);
retv_if(profile_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
func_data = g_malloc0(sizeof(bt_function_data_t));
+ retv_if(func_data == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
func_data->address = g_strdup(address);
func_data->req_id = request_id;
BT_CHECK_PARAMETER(device_address, return);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_path = _bt_get_adapter_path();
#include "bt-service-event.h"
#include "bt-service-util.h"
#include "bt-service-obex-agent.h"
+#include "bt-service-obex-server.h"
#include "marshal.h"
static GDBusConnection *conn = NULL;
+static GDBusConnection *auth_reply_conn = NULL;
static GSList *obex_agent_list = NULL;
typedef struct {
int openobex_id;
int obex_agent_id;
+ int obex_reply_id;
/* callback data */
gpointer authorize_data;
" <method name='Complete'>"
" <annotation name='org.freedesktop.DBus.GLib.Async' value=''/>"
" <arg type='o' name='transfer'/>"
- " </method>"
+" </method>"
" <method name='Release'>"
" <annotation name='org.freedesktop.DBus.GLib.Async' value=''/>"
" </method>"
" </interface>"
"</node>";
+static const gchar obex_service_reply_xml3[] =
+"<node name='/'>"
+" <interface name='org.bluez.obex.reply'>"
+" <method name='ReplyAuthorize'>"
+" <arg type='u' name='accept' direction='in'/>"
+" </method>"
+" </interface>"
+"</node>";
+
static bt_obex_agent_info *__find_obex_agent_info(char *path)
{
GSList *l;
if (info->name == NULL) {
info->name = sender;
} else {
- if (g_strcmp0(sender, info->name) != 0) {
+ if (g_strcmp0(sender, info->name) != 0)
goto fail;
- }
}
if (info->request_cb == NULL)
sender = (char *)g_dbus_method_invocation_get_sender(invocation);
- if (g_strcmp0(sender, info->name) != 0) {
+ if (g_strcmp0(sender, info->name) != 0)
goto fail;
- }
if (info->progress_cb == NULL)
goto fail;
sender = (char *)g_dbus_method_invocation_get_sender(invocation);
- if (g_strcmp0(sender, info->name) != 0) {
+ if (g_strcmp0(sender, info->name) != 0)
goto fail;
- }
if (info->error_cb == NULL)
goto fail;
sender = (char *)g_dbus_method_invocation_get_sender(invocation);
- if (g_strcmp0(sender, info->name) != 0) {
+ if (g_strcmp0(sender, info->name) != 0)
goto fail;
- }
if (info->complete_cb == NULL)
goto fail;
if (info->name) {
/*In H2 if user denies auth,release will come without request and hence
info->name will be NULL */
- if (g_strcmp0(sender, info->name) != 0) {
+ if (g_strcmp0(sender, info->name) != 0)
goto fail;
- }
}
if (info->release_cb == NULL)
info->release_cb(invocation, info->release_data);
return;
+ } else if (g_strcmp0(method_name, "ReplyAuthorize") == 0) {
+ const guint accept;
+
+ g_variant_get(parameters, "(u)", &accept);
+ BT_DBG("Accept: %d", accept);
+
+ if (accept == 0) {
+ BT_DBG("Transfer accepted");
+ _bt_obex_server_reply_accept();
+ } else {
+ BT_ERR("Transfer denied");
+ _bt_obex_server_reject_authorize();
+ }
}
fail:
BT_ERR("Fail case");
g_error_free(error);
return;
}
+ auth_reply_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (error != NULL) {
+ BT_ERR("Fail to get dbus: %s", error->message);
+ g_error_free(error);
+ return;
+ }
}
info = (bt_obex_agent_info *)malloc(sizeof(bt_obex_agent_info));
if (info) {
if (info->obex_agent_id)
g_dbus_connection_unregister_object(conn,
info->obex_agent_id);
+ if (info->obex_reply_id)
+ g_dbus_connection_unregister_object(auth_reply_conn,
+ info->obex_reply_id);
g_free(info);
}
{
bt_obex_agent_info *info;
GDBusProxy *proxy;
- GDBusNodeInfo *new_conn_node;
+ GDBusNodeInfo *new_conn_node = NULL;
+ GDBusNodeInfo *auth_reply_node = NULL;
GError *err = NULL;
info = __find_obex_agent_info((char *)path);
NULL, NULL, &err);
g_dbus_node_info_unref(new_conn_node);
if (err) {
- BT_INFO("Dbus Err: %s", err->message);
+ BT_ERR("Dbus Err: %s", err->message);
g_clear_error(&err);
return FALSE;
}
if (info->openobex_id == 0)
BT_ERR("Error while registering object");
+
new_conn_node = g_dbus_node_info_new_for_xml(obex_service_agent_xml2, NULL);
+ if (new_conn_node == NULL)
+ return FALSE;
info->obex_agent_id = g_dbus_connection_register_object(conn, info->path,
new_conn_node->interfaces[0],
if (info->obex_agent_id == 0)
BT_ERR("Error while registering object");
if (err) {
- BT_INFO("Dbus Err: %s", err->message);
+ BT_ERR("Dbus Err: %s", err->message);
+ g_clear_error(&err);
+ return FALSE;
+ }
+
+ auth_reply_node = g_dbus_node_info_new_for_xml(obex_service_reply_xml3, NULL);
+
+ if (auth_reply_node == NULL) {
+ BT_ERR("Fail to create the node info for xml");
+ return FALSE;
+ }
+
+ info->obex_reply_id = g_dbus_connection_register_object(auth_reply_conn, info->path,
+ auth_reply_node->interfaces[0], &method_table, NULL, NULL, &err);
+ g_dbus_node_info_unref(auth_reply_node);
+ if (info->obex_reply_id == 0)
+ BT_ERR("Error while registering object");
+ if (err) {
+ BT_ERR("Dbus Err: %s", err->message);
g_clear_error(&err);
return FALSE;
}
bt_obex_authorize_cb func, gpointer data)
{
bt_obex_agent_info *info = __find_obex_agent_info(object_path);;
+ if (info == NULL)
+ return;
- if (info) {
- info->authorize_cb = func;
- info->authorize_data = data;
- }
+ info->authorize_cb = func;
+ info->authorize_data = data;
}
void _bt_obex_set_release_cb(char *object_path,
bt_obex_release_cb func, gpointer data)
{
bt_obex_agent_info *info = __find_obex_agent_info(object_path);;
-
- /* Fix : NULL_RETURNS */
if (info == NULL)
return;
bt_obex_request_cb func, gpointer data)
{
bt_obex_agent_info *info = __find_obex_agent_info(object_path);;
-
- /* Fix : NULL_RETURNS */
if (info == NULL)
return;
bt_obex_progress_cb func, gpointer data)
{
bt_obex_agent_info *info = __find_obex_agent_info(object_path);;
-
- /* Fix : NULL_RETURNS */
if (info == NULL)
return;
bt_obex_complete_cb func, gpointer data)
{
bt_obex_agent_info *info = __find_obex_agent_info(object_path);;
-
- /* Fix : NULL_RETURNS */
if (info == NULL)
return;
bt_obex_error_cb func, gpointer data)
{
bt_obex_agent_info *info = __find_obex_agent_info(object_path);;
-
- /* Fix : NULL_RETURNS */
if (info == NULL)
return;
#define BT_OBEX_MANAGER "org.bluez.obex.AgentManager1"
#define BT_OBEX_PATH "/org/bluez/obex"
+#define BT_OBEX_PATH_PREFIX "/opt/usr/media"
+#define BT_OBEX_DEFAULT_PATH "/opt/usr/home/owner/media"
+#define BT_OBEX_PATH_MAX_LENGTH 255
+
typedef struct {
char *filename;
char *device_name;
int transfer_id;
gint64 file_size;
+ gint64 progress;
char *address;
} bt_transfer_info_t;
char *device_name;
char *transfer_path;
char *address;
+ unsigned char contact_auth_info[5];
} bt_auth_info_t;
typedef struct {
bt_server_info_t *custom_server;
} bt_obex_agent_info_t;
+typedef struct {
+ char *path;
+ char *address;
+ gboolean authorized;
+} bt_session_info_t;
+
static GSList *transfers;
static bt_obex_agent_info_t agent_info;
+static GSList *session_list = NULL;
-int _bt_obex_get_native_pid(void)
+static bt_session_info_t *__bt_find_session_by_path(char *transfer_path)
{
- return agent_info.native_server->app_pid;
+ GSList *l;
+ bt_session_info_t *session;
+
+ retv_if(transfer_path == NULL, NULL);
+
+ for (l = session_list; l != NULL; l = l->next) {
+ session = l->data;
+
+ if (session == NULL)
+ continue;
+
+ if (g_strcmp0(session->path, transfer_path) == 0)
+ return session;
+ }
+
+ return NULL;
}
static GQuark __bt_obex_error_quark(void)
bt_transfer_info_t *transfer_info = __bt_find_transfer_by_address(address);
if (transfer_info != NULL) {
int result = BLUETOOTH_ERROR_CANCEL;
- param = g_variant_new("(isssstii)", result,
+ param = g_variant_new("(issssstii)", result,
transfer_info->filename,
transfer_info->type,
transfer_info->device_name,
transfer_info->file_path,
+ transfer_info->address,
transfer_info->file_size,
transfer_info->transfer_id,
agent_info.server_type);
device_path = _bt_get_device_object_path((char *)bdaddress);
retv_if(device_path == NULL, NULL);
- conn = _bt_get_system_gconn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, NULL);
BT_INFO("Device_path %s", device_path);
device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
return NULL;
}
g_variant_get(result, "(@a{sv})", &value);
- g_variant_unref(result);
+ if (value) {
+ GVariant *temp_value = g_variant_lookup_value(value, "Alias",
+ G_VARIANT_TYPE_STRING);
+ g_variant_get(temp_value, "s", &name);
+ if (temp_value)
+ g_variant_unref(temp_value);
+
+ if (name != NULL)
+ DBG_SECURE("Alias Name [%s]", name);
+ else {
+ temp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
+ g_variant_get(temp_value, "s", &name);
+ if (temp_value)
+ g_variant_unref(temp_value);
+ DBG_SECURE("Name = %s", name);
+ }
+ }
+ g_variant_unref(result);
g_object_unref(device_proxy);
+ return name;
+}
+
+static void __bt_get_remote_device_name_authinfo(const char *bdaddress,
+ char **device_name, unsigned char *auth_info)
+{
+ char *device_path = NULL;
+ char *name = NULL;
+ gboolean is_alias_set;
+ GVariant *value;
+ GVariant *result = NULL;
+ GError *err = NULL;
+ GDBusProxy *device_proxy;
+ GDBusConnection *conn;
+
+ ret_if(bdaddress == NULL);
+
+ device_path = _bt_get_device_object_path((char *)bdaddress);
+ ret_if(device_path == NULL);
+
+ conn = _bt_gdbus_get_system_gconn();
+ ret_if(conn == NULL);
+ BT_INFO("Device_path %s", device_path);
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path,
+ BT_PROPERTIES_INTERFACE,
+ NULL, &err);
+
+ g_free(device_path);
+ ret_if(device_proxy == NULL);
+
+ result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
+ g_variant_new("(s)", BT_DEVICE_INTERFACE),
+ G_DBUS_CALL_FLAGS_NONE,
+ DBUS_TIMEOUT, NULL,
+ &err);
+ if (err) {
+ BT_ERR("DBus Error : %s", err->message);
+ g_clear_error(&err);
+ return;
+ }
+ if (result == NULL) {
+ BT_ERR("g_dbus_proxy_call_sync function return NULL");
+ return;
+ }
+ g_variant_get(result, "(@a{sv})", &value);
+
if (value) {
GVariant *temp_value = g_variant_lookup_value(value, "Alias",
G_VARIANT_TYPE_STRING);
- g_variant_get(temp_value, "(s)", &name);
+ g_variant_get(temp_value, "s", &name);
if (temp_value)
g_variant_unref(temp_value);
- BT_INFO("Alias Name: %s", name);
+
+ if (name != NULL)
+ DBG_SECURE("Alias Name [%s]", name);
+ else {
+ temp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
+ g_variant_get(temp_value, "s", &name);
+ if (temp_value)
+ g_variant_unref(temp_value);
+ DBG_SECURE("Name = %s", name);
+ }
+ temp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_BOOLEAN);
+ if (temp_value) {
+ is_alias_set = g_variant_get_boolean(temp_value);
+ g_variant_unref(temp_value);
+ } else {
+ is_alias_set = FALSE;
+ }
+
+ if (is_alias_set == FALSE)
+ __bt_get_auth_info(value, (char *)auth_info);
}
+ g_variant_unref(result);
+ g_object_unref(device_proxy);
- return name;
+ *device_name = g_strdup(name);
+ g_free(name);
+ return;
}
static int __bt_get_transfer_id(const char *path)
GDBusProxy *proxy;
GError *err = NULL;
- conn = _bt_get_session_gconn();
+ conn = _bt_gdbus_get_session_gconn();
retv_if(conn == NULL, NULL);
proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
GDBusConnection *conn;
GDBusProxy *proxy;
GError *err = NULL;
- conn = _bt_get_session_gconn();
+ conn = _bt_gdbus_get_session_gconn();
retv_if(conn == NULL, NULL);
proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
const char *transfer_path)
{
GDBusProxy *transfer_proxy;
- char *bdaddress = NULL;
GVariant *result = NULL;
GError *err = NULL;
GVariantIter *iter = NULL;
}
}
g_variant_iter_free(iter);
- if (transfer_info->type == NULL)
- goto fail;
+
if (transfer_info->address == NULL)
goto fail;
-
transfer_info->device_name = __bt_get_remote_device_name(transfer_info->address);
-
+ transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
if (!transfer_info->device_name)
- transfer_info->device_name = g_strdup(bdaddress);
+ transfer_info->device_name = g_strdup(transfer_info->address);
+
+ if (transfer_info->type == NULL)
+ goto fail;
+
transfer_info->path = g_strdup(transfer_path);
- transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
}
g_object_unref(transfer_proxy);
gpointer user_data)
{
char *device_name = NULL;
+ unsigned char auth_info[5] = {0, };
int result = BLUETOOTH_ERROR_NONE;
GDBusProxy *transfer_properties_proxy;
- char *bdaddress = NULL;
+ char * bdaddress = NULL;
GVariant *ret;
GVariantIter *iter;
GVariant *param = NULL;
GError *err = NULL;
+ bt_session_info_t *session_info = NULL;
BT_DBG(" path [%s] \n", path);
return FALSE;
}
#endif
-
if (iter) {
const gchar *key;
GVariant *val;
gsize len = 0;
while (g_variant_iter_loop(iter, "{sv}", &key, &val)) {
- if (g_strcmp0(key, "Name") == 0) {
+ if (g_strcmp0(key, "Name") == 0)
agent_info.auth_info->filename = g_variant_dup_string(val, &len);
- } else if (g_strcmp0(key, "Address") == 0) {
+ else if (g_strcmp0(key, "Address") == 0)
bdaddress = g_variant_dup_string(val, &len);
- } else if (g_strcmp0(key, "Size") == 0) {
+ else if (g_strcmp0(key, "Size") == 0)
agent_info.auth_info->file_size = g_variant_get_uint64(val);
- }
}
g_variant_iter_free(iter);
}
- device_name = __bt_get_remote_device_name(bdaddress);
+ __bt_get_remote_device_name_authinfo(bdaddress, &device_name, auth_info);
if (!device_name)
device_name = g_strdup(bdaddress);
+ agent_info.auth_info->address = g_strdup(bdaddress);
agent_info.auth_info->device_name = device_name;
+ memcpy(agent_info.auth_info->contact_auth_info, auth_info, 5);
+
+ session_info = __bt_find_session_by_path((char *)path);
+ if (NULL == session_info) {
+ session_info = g_malloc0(sizeof(bt_session_info_t));
+ session_info->path = g_strdup(path);
+ session_info->address = g_strdup(bdaddress);
+ session_info->authorized = FALSE;
+ session_list = g_slist_append(session_list, session_info);
+ }
g_object_unref(transfer_properties_proxy);
+ g_free(bdaddress);
if (agent_info.server_type == BT_CUSTOM_SERVER) {
/* No need to send the event */
_bt_obex_server_accept_authorize(agent_info.auth_info->filename, FALSE);
return TRUE;
}
- param = g_variant_new("(ist)", result,
- agent_info.auth_info->filename,
- agent_info.auth_info->file_size);
- _bt_send_event(BT_OPP_SERVER_EVENT,
- BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
- param);
+
+ if (session_info->authorized == FALSE) {
+ _bt_launch_system_popup(BT_AGENT_EVENT_EXCHANGE_REQUEST, device_name,
+ auth_info, NULL, NULL, BT_OBEX_SERVER_AGENT_PATH);
+ } else {
+ param = g_variant_new("(istss)", result,
+ agent_info.auth_info->filename,
+ agent_info.auth_info->file_size,
+ agent_info.auth_info->address,
+ agent_info.auth_info->device_name);
+ _bt_send_event(BT_OPP_SERVER_EVENT,
+ BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE, param);
+ }
return TRUE;
}
request_info_t *req_info;
GVariant *out_param1 = NULL;
GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
int result = BLUETOOTH_ERROR_NONE;
+ int i = 0;
BT_DBG("%s", transfer_path);
transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
transfer_info->file_path = agent_info.auth_info->file_path;
transfer_info->address = g_strdup(agent_info.auth_info->address);
+
} else {
if (__bt_get_transfer_properties(transfer_info, transfer_path) < 0) {
BT_ERR("Get Properties failed");
- __bt_free_auth_info(agent_info.auth_info);
__bt_free_transfer_info(transfer_info);
- agent_info.auth_info = NULL;
return;
}
agent_info.server_type = BT_FTP_SERVER;
}
- __bt_free_auth_info(agent_info.auth_info);
- agent_info.auth_info = NULL;
-
if (agent_info.server_type == BT_CUSTOM_SERVER) {
if (agent_info.custom_server == NULL) {
__bt_free_transfer_info(transfer_info);
+ __bt_free_auth_info(agent_info.auth_info);
+ agent_info.auth_info = NULL;
return;
}
done:
transfers = g_slist_append(transfers, transfer_info);
- BT_DBG("Transfer id %d\n", transfer_info->transfer_id);
- param = g_variant_new("(isstii)", result,
+ BT_DBG("Transfer id %d", transfer_info->transfer_id);
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < 5; i++) {
+ if (agent_info.auth_info)
+ g_variant_builder_add(builder, "y", agent_info.auth_info->contact_auth_info[i]);
+ }
+
+ param = g_variant_new("(isssstii(ay))", result,
+ transfer_info->device_name,
transfer_info->filename,
transfer_info->type,
+ transfer_info->address,
transfer_info->file_size,
transfer_info->transfer_id,
- agent_info.server_type);
+ agent_info.server_type,
+ builder);
+
+ __bt_free_auth_info(agent_info.auth_info);
+ agent_info.auth_info = NULL;
+
+ g_variant_builder_unref(builder);
+
_bt_send_event(BT_OPP_SERVER_EVENT,
BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
param);
}
void _bt_obex_transfer_progress(const char *transfer_path,
- int transferred)
+ guint64 transferred)
{
BT_DBG("+");
bt_transfer_info_t *transfer_info;
- int progress = 0;
+ int current_progress = 0;
+ int previous_progress;
GVariant *param = NULL;
int result = BLUETOOTH_ERROR_NONE;
transfer_info = __bt_find_transfer_by_path(transfer_path);
ret_if(transfer_info == NULL);
- progress = (int)(((gdouble)transferred /
+ current_progress = (int)(((gdouble)transferred /
+ (gdouble)transfer_info->file_size) * 100);
+
+ previous_progress = (int)(((gdouble)transfer_info->progress /
(gdouble)transfer_info->file_size) * 100);
- param = g_variant_new("(isstiii)", result,
+ if (current_progress == previous_progress) {
+ BT_DBG("Same Percentage Value: Do not emit Signal");
+ return;
+ }
+
+ transfer_info->progress = transferred;
+ param = g_variant_new("(isssstiii)", result,
transfer_info->filename,
transfer_info->type,
+ transfer_info->device_name,
+ transfer_info->address,
transfer_info->file_size,
transfer_info->transfer_id,
- progress,
+ current_progress,
agent_info.server_type);
_bt_send_event(BT_OPP_SERVER_EVENT,
BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
void _bt_obex_transfer_completed(const char *transfer_path, gboolean success)
{
bt_transfer_info_t *transfer_info;
+ GVariantBuilder *builder = NULL;
GVariant *param = NULL;
int result;
+ int i = 0;
BT_DBG("Transfer [%s] Success [%d] \n", transfer_path, success);
result = (success == TRUE) ? BLUETOOTH_ERROR_NONE
transfer_info->device_name = g_strdup(agent_info.auth_info->device_name);
transfer_info->transfer_id = __bt_get_transfer_id(transfer_path);
transfer_info->file_path = agent_info.auth_info->file_path;
+ transfer_info->address = g_strdup(agent_info.auth_info->address);
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < 5; i++)
+ g_variant_builder_add(builder, "y", agent_info.auth_info->contact_auth_info[i]);
- param = g_variant_new("(isstii)", result,
+ param = g_variant_new("(isssstii(ay))", result,
transfer_info->filename,
transfer_info->type,
+ transfer_info->device_name,
+ transfer_info->address,
transfer_info->file_size,
transfer_info->transfer_id,
- agent_info.server_type);
+ agent_info.server_type,
+ builder);
_bt_send_event(BT_OPP_SERVER_EVENT,
BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
param);
+ g_variant_builder_unref(builder);
}
- param = g_variant_new("(isssstii)", result,
+ param = g_variant_new("(issssstii)", result,
transfer_info->filename,
transfer_info->type,
transfer_info->device_name,
transfer_info->file_path,
+ transfer_info->address,
transfer_info->file_size,
transfer_info->transfer_id,
agent_info.server_type);
__bt_free_transfer_info(transfer_info);
}
-void _bt_obex_transfer_connected()
+void _bt_obex_transfer_connected(const char *obj_path)
{
BT_DBG("+");
int result = BLUETOOTH_ERROR_NONE;
GVariant *param = NULL;
+ bt_transfer_info_t *transfer_info = NULL;
+
+ transfer_info = g_new0(bt_transfer_info_t, 1);
+ __bt_get_transfer_properties(transfer_info, obj_path);
+ INFO_SECURE("Address[%s] Name[%s] TransferID[%d] ", transfer_info->address,
+ transfer_info->device_name, transfer_info->transfer_id);
- param = g_variant_new("(i)", result);
+ param = g_variant_new("(issi)", result, transfer_info->address,
+ transfer_info->device_name, transfer_info->transfer_id);
_bt_send_event(BT_OPP_SERVER_EVENT,
BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
param);
+
+ __bt_free_transfer_info(transfer_info);
BT_DBG("-");
}
-void _bt_obex_transfer_disconnected()
+void _bt_obex_transfer_disconnected(char * obj_path)
{
BT_DBG("+");
int result = BLUETOOTH_ERROR_NONE;
GVariant *param = NULL;
+ bt_session_info_t *session = NULL;
+ int transfer_id = -1;
+
+ session = __bt_find_session_by_path(obj_path);
+ ret_if(session == NULL);
- param = g_variant_new("(i)", result);
+ transfer_id = __bt_get_transfer_id(obj_path);
+ DBG_SECURE("transfer_id: [%d]", transfer_id);
+
+ DBG_SECURE("%s", session->address);
+ param = g_variant_new("(isi)", result, session->address, transfer_id);
_bt_send_event(BT_OPP_SERVER_EVENT,
BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
param);
+ session_list = g_slist_remove(session_list, session);
+ g_free(session->address);
+ g_free(session->path);
+ g_free(session);
BT_DBG("-");
}
{
GDBusConnection *g_conn;
GDBusProxy *manager_proxy;
+ GVariant *result = NULL;
GError *g_error = NULL;
/* Get the session bus. */
- g_conn = _bt_get_session_gconn();
+ g_conn = _bt_gdbus_get_session_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
_bt_obex_agent_new(BT_OBEX_SERVER_AGENT_PATH);
BT_OBEX_MANAGER,
NULL, &g_error);
- if (manager_proxy == NULL) {
+ if (manager_proxy == NULL)
return BLUETOOTH_ERROR_INTERNAL;
- }
- g_dbus_proxy_call_sync(manager_proxy, "RegisterAgent",
+ result = g_dbus_proxy_call_sync(manager_proxy, "RegisterAgent",
g_variant_new("(o)", BT_OBEX_SERVER_AGENT_PATH),
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL,
return BLUETOOTH_ERROR_INTERNAL;
}
+ if (result)
+ g_variant_unref(result);
+
agent_info.proxy = manager_proxy;
return BLUETOOTH_ERROR_NONE;
int _bt_unregister_obex_server(void)
{
+ GVariant *result = NULL;
GError *g_error = NULL;
retv_if(agent_info.proxy == NULL,
BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(agent_info.proxy, "UnregisterAgent",
+ result = g_dbus_proxy_call_sync(agent_info.proxy, "UnregisterAgent",
g_variant_new("(o)", BT_OBEX_SERVER_AGENT_PATH),
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL,
BT_ERR("Agent unregistration failed: %s", g_error->message);
g_error_free(g_error);
}
+
+ if (result)
+ g_variant_unref(result);
+
_bt_obex_agent_destroy(BT_OBEX_SERVER_AGENT_PATH);
g_object_unref(agent_info.proxy);
agent_info.proxy = NULL;
return TRUE;
}
+char *__bt_transfer_folder_path(char *dest_path)
+{
+ char *dst_path = (char *)g_malloc0(BT_OBEX_PATH_MAX_LENGTH);
+ if (g_str_has_prefix(dest_path, BT_OBEX_PATH_PREFIX))
+ snprintf(dst_path, BT_OBEX_PATH_MAX_LENGTH, BT_OBEX_DEFAULT_PATH"%s", dest_path + strlen(BT_OBEX_PATH_PREFIX));
+ else
+ snprintf(dst_path, BT_OBEX_PATH_MAX_LENGTH, "%s", dest_path);
+
+ BT_INFO("obex transfed path : %s", dst_path);
+ return dst_path;
+}
+
int _bt_obex_server_allocate(char *sender, const char *dest_path, int app_pid, gboolean is_native)
{
BT_DBG("+");
- if (__bt_check_folder_path(dest_path) == FALSE)
+
+ char *dst_path;
+ dst_path = __bt_transfer_folder_path((char *)dest_path);
+
+ if (__bt_check_folder_path(dst_path) == FALSE) {
+ g_free(dst_path);
return BLUETOOTH_ERROR_INVALID_PARAM;
+ }
if (is_native == TRUE) {
- retv_if(agent_info.native_server,
- BLUETOOTH_ERROR_DEVICE_BUSY);
+ if (agent_info.native_server) {
+ BT_ERR("obex native server busy");
+ g_free(dst_path);
+ return BLUETOOTH_ERROR_DEVICE_BUSY;
+ }
/* Force to change the control to native */
agent_info.native_server = g_malloc0(sizeof(bt_server_info_t));
- agent_info.native_server->dest_path = g_strdup(dest_path);
+ agent_info.native_server->dest_path = g_strdup(dst_path);
agent_info.native_server->sender = g_strdup(sender);
agent_info.native_server->app_pid = app_pid;
agent_info.server_type = BT_NATIVE_SERVER;
_bt_unregister_osp_server_in_agent(BT_OBEX_SERVER, NULL);
} else {
- retv_if(agent_info.custom_server,
- BLUETOOTH_ERROR_DEVICE_BUSY);
+ if (agent_info.custom_server) {
+ BT_ERR("obex custom server busy");
+ g_free(dst_path);
+ return BLUETOOTH_ERROR_DEVICE_BUSY;
+ }
/* Force to change the control to custom */
agent_info.custom_server = g_malloc0(sizeof(bt_server_info_t));
- agent_info.custom_server->dest_path = g_strdup(dest_path);
+ agent_info.custom_server->dest_path = g_strdup(dst_path);
agent_info.custom_server->sender = g_strdup(sender);
agent_info.custom_server->app_pid = app_pid;
agent_info.server_type = BT_CUSTOM_SERVER;
_bt_register_osp_server_in_agent(BT_OBEX_SERVER, NULL, NULL, -1);
}
+
+ g_free(dst_path);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
g_variant_new("(s)", &file_path));
agent_info.auth_info->reply_context = NULL;
agent_info.auth_info->file_path = g_strdup(file_path);
+ g_free(agent_info.auth_info->filename);
+ agent_info.auth_info->filename = g_strdup(filename);
return BLUETOOTH_ERROR_NONE;
}
+void _bt_obex_server_reply_accept(void)
+{
+ GVariant *param = NULL;
+ bt_session_info_t *session_info = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+ param = g_variant_new("(istss)", result,
+ agent_info.auth_info->filename,
+ agent_info.auth_info->file_size,
+ agent_info.auth_info->address,
+ agent_info.auth_info->device_name);
+ BT_INFO("Send Obex Authorize");
+ _bt_send_event(BT_OPP_SERVER_EVENT, BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE, param);
+
+ session_info = __bt_find_session_by_path(agent_info.auth_info->transfer_path);
+
+ if (NULL == session_info)
+ BT_ERR("Couldn't get the session info from the list");
+ else
+ session_info->authorized = TRUE;
+}
+
int _bt_obex_server_reject_authorize(void)
{
GError *g_error;
gboolean is_native)
{
bt_server_info_t *server_info;
-
BT_CHECK_PARAMETER(dest_path, return);
+ char *dst_path;
+ dst_path = __bt_transfer_folder_path((char *)dest_path);
+
DIR *dp = NULL;
- dp = opendir(dest_path);
+ dp = opendir(dst_path);
if (dp == NULL) {
BT_ERR("The directory does not exist");
+ g_free(dst_path);
return BLUETOOTH_ERROR_INVALID_PARAM;
}
else
server_info = agent_info.custom_server;
- retv_if(server_info == NULL,
- BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST);
+ if (!server_info) {
+ BT_ERR("obex server info is NULL");
+ g_free(dst_path);
+ return BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST;
+ }
g_free(server_info->dest_path);
- server_info->dest_path = g_strdup(dest_path);
+ server_info->dest_path = g_strdup(dst_path);
+ g_free(dst_path);
return BLUETOOTH_ERROR_NONE;
}
int _bt_obex_server_set_root(const char *root)
{
+ GVariant *result = NULL;
GError *g_error = NULL;
GVariant *folder = NULL;
char *string = "Root";
BT_CHECK_PARAMETER(root, return);
- retv_if(agent_info.proxy == NULL,
- BLUETOOTH_ERROR_INTERNAL);
+ char *dst_root;
+ dst_root = __bt_transfer_folder_path((char *)root);
+
+ if (!agent_info.proxy) {
+ BT_ERR("obex agent_info proxy error");
+ g_free(dst_root);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
- dp = opendir(root);
+ dp = opendir(dst_root);
if (dp == NULL) {
BT_ERR("The directory does not exist");
+ g_free(dst_root);
return BLUETOOTH_ERROR_INVALID_PARAM;
}
closedir(dp);
- folder = g_variant_new_string(root);
- g_dbus_proxy_call_sync(agent_info.proxy, "SetProperty",
+ folder = g_variant_new_string(dst_root);
+ result = g_dbus_proxy_call_sync(agent_info.proxy, "SetProperty",
g_variant_new("(sv)", string, folder),
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL,
if (g_error) {
BT_ERR("SetProperty Fail: %s", g_error->message);
g_error_free(g_error);
+ g_free(dst_root);
return BLUETOOTH_ERROR_INTERNAL;
}
+ if (result)
+ g_variant_unref(result);
+
+ g_free(dst_root);
return BLUETOOTH_ERROR_NONE;
}
{
bt_transfer_info_t *transfer = NULL;
GDBusProxy *proxy;
+ GVariant *result = NULL;
GError *err = NULL;
BT_DBG("+");
transfer = __bt_find_transfer_by_id(transfer_id);
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(proxy, "Cancel", NULL,
+ result = g_dbus_proxy_call_sync(proxy, "Cancel", NULL,
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIMEOUT, NULL, &err);
if (err) {
BT_ERR("Dbus Err: %s", err->message);
g_clear_error(&err);
}
+
g_object_unref(proxy);
+ if (result)
+ g_variant_unref(result);
+
return BLUETOOTH_ERROR_NONE;
}
{
BT_CHECK_PARAMETER(activated, return);
- if (agent_info.custom_server) {
+ if (agent_info.custom_server)
*activated = TRUE;
- } else {
+ else
*activated = FALSE;
- }
return BLUETOOTH_ERROR_NONE;
}
{
BT_CHECK_PARAMETER(allocation, return);
- if (agent_info.native_server || agent_info.custom_server) {
+ if (agent_info.native_server || agent_info.custom_server)
*allocation = TRUE;
- } else {
+ else
*allocation = FALSE;
- }
return BLUETOOTH_ERROR_NONE;
}
{
BT_CHECK_PARAMETER(receiving, return);
- if (transfers == NULL || g_slist_length(transfers) == 0) {
+ if (transfers == NULL || g_slist_length(transfers) == 0)
*receiving = FALSE;
- } else {
+ else
*receiving = TRUE;
- }
return BLUETOOTH_ERROR_NONE;
}
return BLUETOOTH_ERROR_NONE;
}
+int _bt_opp_get_server_progress(int transfer_id, guint8 *progress)
+{
+ bt_transfer_info_t *requested_transfer = NULL;
+ requested_transfer = __bt_find_transfer_by_id(transfer_id);
+ if (requested_transfer == NULL) {
+ BT_ERR("No Matching Inbound transfer");
+ return BLUETOOTH_ERROR_NOT_FOUND;
+ }
+
+ *progress = (int)(((double)requested_transfer->progress /
+ requested_transfer->file_size) * 100);
+
+ BT_DBG("Percentage: %d", *progress);
+ return BLUETOOTH_ERROR_NONE;
+}
/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ * 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>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "bt-service-oob.h"
#include "bt-service-event.h"
+static int __get_oob_data_from_variant(GVariant *variant,
+ unsigned char *buf, int size)
+{
+ int i;
+ unsigned char *v;
+
+ i = g_variant_get_size(variant);
+ v = (unsigned char *)g_variant_get_data(variant);
+ if (i && v) {
+ i = i > size ? size : i;
+ memcpy(buf, v, i);
+ }
+
+ return i;
+}
+
int _bt_oob_read_local_data(bt_oob_data_t *local_oob_data)
{
GDBusProxy *proxy;
GVariant *reply;
GError *err = NULL;
char *adapter_path;
- unsigned char *local_hash = NULL;
- unsigned char *local_randomizer = NULL;
GDBusConnection *conn;
- GVariant *hash = NULL;
- GVariant *randomizer = NULL;
+ GVariant *hash192 = NULL;
+ GVariant *randomizer192 = NULL;
+ GVariant *hash256 = NULL;
+ GVariant *randomizer256 = NULL;
BT_CHECK_PARAMETER(local_oob_data, return);
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_path = _bt_get_adapter_path();
retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
-
proxy = g_dbus_proxy_new_sync(conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
BT_BLUEZ_NAME, adapter_path,
return BLUETOOTH_ERROR_INTERNAL;
}
- g_variant_get(reply, "(@ay@ay)", &hash, &randomizer);
+ g_variant_get(reply, "(@ay@ay@ay@ay)", &hash192, &randomizer192,
+ &hash256, &randomizer256);
g_variant_unref(reply);
- if (hash != NULL) {
- local_oob_data->hash_len = (unsigned int)g_variant_get_size(hash);
- local_hash = (unsigned char *)g_variant_get_data(hash);
- } else {
- BT_ERR("hash is NULL");
- return BLUETOOTH_ERROR_INTERNAL;
+ if (hash192) {
+ local_oob_data->hash_len = __get_oob_data_from_variant(hash192,
+ local_oob_data->hash,
+ sizeof(local_oob_data->hash));
+ g_variant_unref(hash192);
}
- g_variant_unref(hash);
-
- if (randomizer != NULL) {
- local_oob_data->randomizer_len = (unsigned int)g_variant_get_size(randomizer);
- local_randomizer = (unsigned char *)g_variant_get_data(randomizer);
- } else {
- BT_ERR("randomizer is NULL");
- return BLUETOOTH_ERROR_INTERNAL;
+ if (randomizer192) {
+ local_oob_data->randomizer_len = __get_oob_data_from_variant(randomizer192,
+ local_oob_data->randomizer,
+ sizeof(local_oob_data->randomizer));
+ g_variant_unref(randomizer192);
}
- g_variant_unref(randomizer);
-
- if (local_oob_data->hash_len > 0)
- memcpy(local_oob_data->hash, local_hash, local_oob_data->hash_len);
+ if (hash256) {
+ local_oob_data->hash256_len = __get_oob_data_from_variant(hash256,
+ local_oob_data->hash256,
+ sizeof(local_oob_data->hash256));
+ g_variant_unref(hash256);
+ }
- if (local_oob_data->randomizer_len > 0)
- memcpy(local_oob_data->randomizer, local_randomizer,
- local_oob_data->randomizer_len);
+ if (randomizer256) {
+ local_oob_data->randomizer256_len = __get_oob_data_from_variant(randomizer256,
+ local_oob_data->randomizer256,
+ sizeof(local_oob_data->randomizer256));
+ g_variant_unref(randomizer256);
+ }
return BLUETOOTH_ERROR_NONE;
}
bluetooth_device_address_t *remote_device_address,
bt_oob_data_t *remote_oob_data)
{
+ int i;
GDBusProxy *proxy;
GVariant *reply;
GError *err = NULL;
unsigned char *remote_hash;
unsigned char *remote_randomizer;
GDBusConnection *conn;
- GArray *in_param1 = NULL;
- GArray *in_param2 = NULL;
- GVariant *hash;
- GVariant *randomizer;
+ GVariantBuilder *builder;
+ GVariantBuilder *builder2;
+ GVariant *hash192;
+ GVariant *randomizer192;
+ GVariant *hash256;
+ GVariant *randomizer256;
BT_CHECK_PARAMETER(remote_device_address, return);
BT_CHECK_PARAMETER(remote_oob_data, return);
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_path = _bt_get_adapter_path();
retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
- _bt_convert_addr_type_to_string(address,
- remote_device_address->addr);
+ _bt_convert_addr_type_to_string(address, remote_device_address->addr);
proxy = g_dbus_proxy_new_sync(conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
return BLUETOOTH_ERROR_INTERNAL;
}
+ /* Remote address */
+ dev_addr = g_strdup(address);
+
+ /* P-192 */
remote_hash = remote_oob_data->hash;
remote_randomizer = remote_oob_data->randomizer;
- dev_addr = g_strdup(address);
- BT_DBG("remote hash len = [%d] and remote random len = [%d]\n",
- remote_oob_data->hash_len, remote_oob_data->randomizer_len);
- /*Create array of bytes variant*/
- in_param1 = g_array_new(TRUE, TRUE, sizeof(gchar));
- in_param2 = g_array_new(TRUE, TRUE, sizeof(gchar));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ builder2 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+
+ for (i = 0; i < remote_oob_data->hash_len; i++)
+ g_variant_builder_add(builder, "y", remote_hash[i]);
+
+ for (i = 0; i < remote_oob_data->randomizer_len; i++)
+ g_variant_builder_add(builder2, "y", remote_randomizer[i]);
+
+ hash192 = g_variant_new("ay", builder);
+ randomizer192 = g_variant_new("ay", builder2);
- g_array_append_vals(in_param1, remote_hash,
- remote_oob_data->hash_len);
- g_array_append_vals(in_param2, remote_randomizer,
- remote_oob_data->randomizer_len);
+ g_variant_builder_unref(builder2);
+ g_variant_builder_unref(builder);
- hash = g_variant_new_from_data((const GVariantType *)"ay",
- in_param1->data, in_param1->len,
- TRUE, NULL, NULL);
+ /* P-256 */
+ remote_hash = remote_oob_data->hash256;
+ remote_randomizer = remote_oob_data->randomizer256;
- randomizer = g_variant_new_from_data((const GVariantType *)"ay",
- in_param2->data, in_param2->len,
- TRUE, NULL, NULL);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ builder2 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- g_array_free(in_param1, TRUE);
- g_array_free(in_param2, TRUE);
+ for (i = 0; i < remote_oob_data->hash256_len; i++)
+ g_variant_builder_add(builder, "y", remote_hash[i]);
- /* Call AddRemoteData Method*/
+ for (i = 0; i < remote_oob_data->randomizer256_len; i++)
+ g_variant_builder_add(builder2, "y", remote_randomizer[i]);
+
+ hash256 = g_variant_new("ay", builder);
+ randomizer256 = g_variant_new("ay", builder2);
+
+ g_variant_builder_unref(builder2);
+ g_variant_builder_unref(builder);
+
+ /* Call AddRemoteData Method */
reply = g_dbus_proxy_call_sync(proxy, "AddRemoteData",
- g_variant_new("(s@ay@ay)", dev_addr, hash, randomizer),
+ g_variant_new("(s@ay@ay@ay@ay)", dev_addr,
+ hash192, randomizer192, hash256, randomizer256),
G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &err);
g_object_unref(proxy);
g_free(dev_addr);
- /* Check the reply*/
+ /* Check the reply */
if (reply == NULL) {
BT_ERR("AddRemoteData dBUS-RPC is failed");
if (err != NULL) {
}
return BLUETOOTH_ERROR_INTERNAL;
}
-
g_variant_unref(reply);
+
return BLUETOOTH_ERROR_NONE;
}
BT_CHECK_PARAMETER(remote_device_address, return);
- conn = _bt_get_system_conn();
+ conn = _bt_gdbus_get_system_gconn();
retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
adapter_path = _bt_get_adapter_path();
g_variant_unref(reply);
return BLUETOOTH_ERROR_NONE;
}
-
#include <dlog.h>
#include <string.h>
#include <mime_type.h>
-
+#include <aul.h>
#include <glib.h>
#include <gio/gio.h>
#include "bt-service-util.h"
#include "bt-service-opp-client.h"
#include "bt-service-obex-agent.h"
+#include "bt-service-adapter.h"
+
+#define BT_MIME_TYPE_MAX_LEN 20
static GSList *transfer_list = NULL;
bt_sending_info_t *sending_info;
#define DBUS_TIEMOUT 20 * 1000 /* 20 Seconds */
static gboolean __bt_sending_release();
-static void _bt_remove_session();
+static int _bt_remove_session();
static int __bt_opp_client_start_sending(int request_id, char *address,
char **file_name_array, int file_count);
return FALSE;
}
-gboolean _bt_obex_client_progress(const char *transfer_path, int transferred)
+gboolean _bt_obex_client_progress(const char *transfer_path, guint64 transferred)
{
BT_DBG("+");
int percentage_progress;
- gint64 size;
+ int previous_progress;
+ guint64 size;
int result = BLUETOOTH_ERROR_NONE;
GVariant *param = NULL;
retv_if(sending_info == NULL, TRUE);
}
size = sending_info->transfer_info->size;
-
if (size != 0)
- percentage_progress = (int)(((gdouble)transferred /
- (gdouble)size) * 100);
+ percentage_progress = (int)(((gdouble)transferred /(gdouble)size) * 100);
else
percentage_progress = 0;
sending_info->transfer_info->transfer_status = BT_TRANSFER_STATUS_PROGRESS;
sending_info->result = result;
+ previous_progress = (int)(((gdouble)sending_info->transfer_info->progress /(gdouble)size) * 100);
+ if (percentage_progress == previous_progress &&
+ sending_info->transfer_info->progress) {
+ sending_info->transfer_info->progress = transferred;
+ return TRUE;
+ }
+ BT_DBG("Sending progress [prev %d] [curr %d]",
+ previous_progress, percentage_progress);
+
+ sending_info->transfer_info->progress = transferred;
+
/* Send the event in only error none case */
param = g_variant_new("(istii)", result,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
percentage_progress,
sending_info->request_id);
+
+
_bt_send_event(BT_OPP_CLIENT_EVENT,
BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
param);
if (!success) { /*In case of remote device reject, we need to send BLUETOOTH_EVENT_OPC_DISCONNECTED */
BT_DBG("completed with error");
if (!sending_info->is_canceled) {
- param = g_variant_new("(isti)", result,
+ param = g_variant_new("(issti)", result,
+ sending_info->address,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
sending_info->request_id);
} else {
BT_DBG("complete success");
/* Send the event in only error none case */
- param = g_variant_new("(isti)", result,
+ param = g_variant_new("(issti)", result,
+ sending_info->address,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
sending_info->request_id);
}
/* Get the session bus. */
- g_conn = _bt_get_session_gconn();
+ g_conn = _bt_gdbus_get_session_gconn();
retv_if(g_conn == NULL, FALSE);
properties_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_OBEXD_DBUS_NAME,
sending_info->transfer_info->transfer_status = BT_TRANSFER_STATUS_STARTED;
sending_info->result = result;
- param = g_variant_new("(isti)", result,
+
+ param = g_variant_new("(issti)", result,
+ sending_info->address,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
sending_info->request_id);
ret_if(info == NULL);
- for (i = 0; i < info->file_count; i++) {
+ for (i = 0; i < info->file_count; i++)
g_free(info->file_path[i]);
- }
_bt_delete_request_id(info->request_id);
GError *error = NULL;
int result = BLUETOOTH_ERROR_NONE;
GVariant *param = NULL;
- g_dbus_proxy_call_finish(proxy, res, &error);
+ GVariant *reply = NULL;
+
+ reply = g_dbus_proxy_call_finish(proxy, res, &error);
if (proxy)
g_object_unref(proxy);
+ if (reply)
+ g_variant_unref(reply);
if (error) {
BT_ERR("%s", error->message);
BT_DBG("Session Removed");
}
- if (sending_info->result != BLUETOOTH_ERROR_CANCEL_BY_USER)
- sending_info->result = result;
-
+ sending_info->result = result;
param = g_variant_new("(isi)", sending_info->result,
sending_info->address,
sending_info->request_id);
return;
}
-static void _bt_remove_session()
+static int _bt_remove_session()
{
GDBusConnection *g_conn;
GDBusProxy *session_proxy;
GError *err = NULL;
- g_conn = _bt_get_session_gconn();
- ret_if(g_conn == NULL);
- ret_if(sending_info->session_path == NULL);
+ g_conn = _bt_gdbus_get_session_gconn();
+ retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ retv_if(sending_info->session_path == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
session_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
NULL, BT_OBEXD_DBUS_NAME,
BT_OBEX_CLIENT_INTERFACE,
NULL, &err);
- ret_if(session_proxy == NULL);
+ retv_if(session_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
g_dbus_proxy_call(session_proxy, "RemoveSession",
g_variant_new("(o)", sending_info->session_path),
(GAsyncReadyCallback)__bt_sending_release_cb,
NULL);
+ return BLUETOOTH_ERROR_NONE;
}
static gboolean __bt_sending_release()
retv_if(sending_info == NULL, FALSE);
- _bt_remove_session();
+ retv_if(_bt_remove_session() != BLUETOOTH_ERROR_NONE, FALSE);
+
BT_DBG("-");
return TRUE;
}
if (sending_info->transfer_info->transfer_status == BT_TRANSFER_STATUS_PROGRESS ||
sending_info->transfer_info->transfer_status == BT_TRANSFER_STATUS_STARTED) {
BT_INFO("Abnormal termination");
- param = g_variant_new("(isti)", sending_info->result,
+ param = g_variant_new("(issti)", sending_info->result,
+ sending_info->address,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
sending_info->request_id);
GVariantIter *iter = NULL;
value = g_dbus_proxy_call_finish(proxy, res, &error);
if (error) {
+ g_dbus_error_strip_remote_error(error);
BT_ERR("%s", error->message);
- g_error_free(error);
- if (proxy)
- g_object_unref(proxy);
+ /* If Obex is not able to open a file then continue with other if any */
+ if (g_strcmp0("Unable to open file", error->message) == 0) {
+ GVariant *param = NULL;
+ gint64 size = 0;
+
+ BT_ERR("Unable to open file [%s]", sending_info->file_name_array[file_offset]);
+
+ param = g_variant_new("(issti)", BLUETOOTH_ERROR_NOT_FOUND,
+ sending_info->address,
+ sending_info->file_name_array[file_offset],
+ size,
+ sending_info->request_id);
+ _bt_send_event(BT_OPP_CLIENT_EVENT,
+ BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
+ param);
+
+ param = g_variant_new("(issti)", BLUETOOTH_ERROR_NOT_FOUND,
+ sending_info->address,
+ sending_info->file_name_array[file_offset],
+ size,
+ sending_info->request_id);
+ _bt_send_event(BT_OPP_CLIENT_EVENT,
+ BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
+ param);
+ g_error_free(error);
+ if (proxy)
+ g_object_unref(proxy);
+ file_offset++;
+ _bt_sending_files();
+ }
return;
}
if (proxy)
GVariant *val;
gsize len = 0;
while (g_variant_iter_loop(iter, "{sv}", &key, &val)) {
- if (g_strcmp0(key, "Name") == 0) {
+ if (g_strcmp0(key, "Name") == 0)
transfer_name = g_variant_dup_string(val, &len);
- } else if (g_strcmp0(key, "Filename") == 0) {
+ else if (g_strcmp0(key, "Filename") == 0)
file_name = g_variant_dup_string(val, &len);
- } else if (g_strcmp0(key, "Size") == 0) {
+ else if (g_strcmp0(key, "Size") == 0)
size = g_variant_get_uint64(val);
- }
}
g_variant_iter_free(iter);
}
sending_info->transfer_info->transfer_name = g_strdup(transfer_name);
sending_info->transfer_info->file_name = g_strdup(file_name);
sending_info->transfer_info->size = size;
+ sending_info->transfer_info->progress = 0;
sending_info->transfer_info->transfer_path = session_path;
sending_info->transfer_info->transfer_status = BT_TRANSFER_STATUS_QUEUED;
sending_info->result = BLUETOOTH_ERROR_NONE;
file_offset++;
+ g_free((gchar *)transfer_name);
+ g_free((gchar *)file_name);
}
void _bt_sending_files(void)
GError *err = NULL;
GDBusConnection *g_conn;
GDBusProxy *client_proxy;
- char *mimetype = NULL;
- char *ext = NULL;
+ char mime_type[BT_MIME_TYPE_MAX_LEN + 1] = { 0 };
if (sending_info == NULL)
return;
if (file_offset < sending_info->file_count) {
/* Get the session bus. */
- g_conn = _bt_get_session_gconn();
+ g_conn = _bt_gdbus_get_session_gconn();
ret_if(g_conn == NULL);
client_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
BT_OBEX_OBJECT_PUSH_INTERFACE,
NULL, &err);
ret_if(client_proxy == NULL);
+ if (aul_get_mime_from_file(sending_info->file_name_array[file_offset],
+ mime_type, BT_MIME_TYPE_MAX_LEN) == AUL_R_OK) {
+ BT_DBG("MLME type = %s", mime_type);
+
+ /* For IOPT compliance, change "text/x-iMelody" to "audio/imelody"
+ * because few devices(multimedia players) reject the OPP put for text objects
+ * since they support only multimedia files exchange */
+ if (!strcasecmp(mime_type, "text/x-iMelody")) {
+ strncpy(mime_type, "audio/imelody", BT_MIME_TYPE_MAX_LEN);
+ BT_DBG("over writing mime type to = %s", mime_type);
+ }
+ if (!strcasecmp(mime_type, "text/vcard")) {
+ strncpy(mime_type, "text/x-vcard", BT_MIME_TYPE_MAX_LEN);
+ BT_DBG("over writing mime type to = %s", mime_type);
+ }
+ }
BT_DBG("Calling SendFile");
- ext = strrchr(sending_info->file_name_array[file_offset], '.');
-
- if (ext != NULL && (!strcmp(ext, ".imy")))
- mimetype = g_strdup("audio/imelody");
g_dbus_proxy_call(client_proxy, "SendFile",
g_variant_new("(ss)", sending_info->file_name_array[file_offset],
- mimetype),
+ mime_type),
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIEMOUT, NULL,
(GAsyncReadyCallback)__bt_send_file_cb,
if (err != NULL) {
BT_ERR("Calling SendFile failed: [%s]\n", err->message);
g_clear_error(&err);
- g_free(mimetype);
return;
}
- g_free(mimetype);
} else {
file_offset = 0;
__bt_sending_release();
GVariant *param = NULL;
value = g_dbus_proxy_call_finish(proxy, res, &error);
- if (proxy)
- g_object_unref(proxy);
-
if (value) {
g_variant_get(value, "(o)", &session_path);
g_variant_unref(value);
sending_info->session_path = g_strdup(session_path);
}
g_free(session_path);
+ g_object_unref(proxy);
ret_if(sending_info == NULL);
sending_info->result = result;
if (result != BLUETOOTH_ERROR_NONE) {
BT_ERR("Calling __bt_sending_release");
- __bt_sending_release();
+ gboolean ret = __bt_sending_release();
__bt_free_sending_info(sending_info);
sending_info = NULL;
+
+ if (ret == FALSE) {
+ BT_DBG("ReleaseSession Not called");
+ /* Operate remain works */
+ if (g_slist_length(transfer_list) > 0) {
+ bt_sending_data_t *data = NULL;
+
+ data = transfer_list->data;
+ ret_if(data == NULL);
+
+ transfer_list = g_slist_remove(transfer_list, data);
+
+ BT_DBG("calling __bt_opp_client_start_sending");
+
+ if (__bt_opp_client_start_sending(data->request_id,
+ data->address, data->file_path,
+ data->file_count) != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Sending Enqueued Transfer Failed");
+ }
+ }
+ }
} else {
BT_DBG("Calling sending_files");
_bt_sending_files();
BT_CHECK_PARAMETER(file_name_array, return);
/* Get the session bus. */
- g_conn = _bt_get_session_gconn();
+ g_conn = _bt_gdbus_get_session_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
client_proxy = g_dbus_proxy_new_sync(g_conn, G_DBUS_PROXY_FLAGS_NONE,
_bt_opp_client_event_init();
//_bt_obex_client_started(agent_path);
- BT_DBG("Going to call CreateSession");
-
- g_dbus_proxy_call(client_proxy, "CreateSession",
+ BT_DBG("Adapter Status %d", _bt_adapter_get_status());
+ if (_bt_adapter_get_status() == BT_ACTIVATED) {
+ BT_DBG("Going to call CreateSession");
+ g_dbus_proxy_call(client_proxy, "CreateSession",
g_variant_new("(sa{sv})", address, builder),
G_DBUS_CALL_FLAGS_NONE,
DBUS_TIEMOUT, NULL,
(GAsyncReadyCallback)__bt_create_session_cb,
NULL);
+ } else {
+ GVariant *param = g_variant_new("(isi)", BLUETOOTH_ERROR_INTERNAL,
+ sending_info->address, sending_info->request_id);
+
+ BT_DBG("Address[%s] RequestID[%d]", sending_info->address, sending_info->request_id);
+ _bt_send_event(BT_OPP_CLIENT_EVENT, BLUETOOTH_EVENT_OPC_CONNECTED,
+ param);
+ __bt_free_sending_info(sending_info);
+ sending_info = NULL;
+ }
g_variant_builder_unref(builder);
BT_DBG("-");
} else {
/* Insert data in the queue */
data = g_malloc0(sizeof(bt_sending_data_t));
- /* Fix : NULL_RETURNS */
if (data == NULL)
return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
GError *err = NULL;
int result = BLUETOOTH_ERROR_CANCEL_BY_USER;
+ GVariant *ret = NULL;
GVariant *param = NULL;
retv_if(sending_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
if (sending_info->transfer_info) {
- g_dbus_proxy_call_sync(sending_info->transfer_info->proxy,
+ ret = g_dbus_proxy_call_sync(sending_info->transfer_info->proxy,
"Cancel", NULL,
G_DBUS_CALL_FLAGS_NONE, -1,
NULL, &err);
- param = g_variant_new("(isti)", result,
+ if (ret == NULL) {
+ if (err != NULL) {
+ BT_ERR("Cancel Error: %s\n", err->message);
+ g_error_free(err);
+ }
+ } else {
+ g_variant_unref(ret);
+ }
+
+ param = g_variant_new("(issti)", result,
+ sending_info->address,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
sending_info->request_id);
sending_info->result = result;
if (!sending_info->is_canceled) {
- param = g_variant_new("(isti)", result,
+ param = g_variant_new("(issti)", result,
+ sending_info->address,
sending_info->transfer_info->file_name,
sending_info->transfer_info->size,
sending_info->request_id);
}
BT_DBG("-");
}
+
+int _bt_opp_get_client_progress(guint8 *progress)
+{
+ if (sending_info == NULL || sending_info->transfer_info == NULL) {
+ BT_ERR("No Active Outbound transfer");
+ return BLUETOOTH_ERROR_NOT_FOUND;
+ }
+
+ *progress = (int)(((double)sending_info->transfer_info->progress /
+ sending_info->transfer_info->size) * 100);
+
+ BT_DBG("Percentage: %d", *progress);
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_cancel_queued_transfers(void)
+{
+ bt_sending_data_t *data = NULL;
+ GVariant *param = NULL;
+
+ BT_INFO("Cancel queued Transfers:: Length of transfer list is %d",
+ g_slist_length(transfer_list));
+
+ while (transfer_list) {
+ data = transfer_list->data;
+ param = g_variant_new("(isi)", BLUETOOTH_ERROR_INTERNAL,
+ data->address, data->request_id);
+
+ BT_DBG("Address[%s] RequestID[%d]", data->address, data->request_id);
+ _bt_send_event(BT_OPP_CLIENT_EVENT, BLUETOOTH_EVENT_OPC_CONNECTED,
+ param);
+
+ transfer_list = g_slist_remove(transfer_list, data);
+ }
+}
#include <string.h>
#include <malloc.h>
#include <stacktrim.h>
-#if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
#include <syspopup_caller.h>
-#endif
#include <vconf.h>
#include <storage.h>
#include <glib.h>
#include <gio/gio.h>
-#define PBAP_UUID "0000112f-0000-1000-8000-00805f9b34fb"
#define PBAP_OBEX_CLIENT_SERVICE "org.bluez.obex"
#define PBAP_OBEX_CLIENT_PATH "/org/bluez/obex"
#define PBAP_OBEX_CLIENT_INTERFACE "org.bluez.obex.Client1"
#define PBAP_NUM_OF_FIELDS_ENTRY 29
#define PBAP_FIELD_ALL (0xFFFFFFFFFFFFFFFFULL)
-#define PBAP_DEFAULT_DOWNLAOD_PATH "/opt/usr/media/Downloads/"
+#define PBAP_DEFAULT_DOWNLAOD_PATH "/opt/usr/home/owner/media/Downloads"
#define PBAP_DEFAULT_FILE_NAME "pb.vcf"
char *FIELDS[] = {
static char *g_pbap_session_path = NULL;
static char *g_pbap_server_address = NULL;
-static GDBusConnection *dbus_connection = NULL;
static GDBusProxy *g_pbap_proxy = NULL;
static struct {
BT_DBG("Session Path = %s\n", g_pbap_session_path);
result = BLUETOOTH_ERROR_NONE;
g_pbap_server_address = g_strdup(address_string);
+
+ g_variant_unref(value);
}
signal = g_variant_new("(is)", result, address_string);
int _bt_pbap_connect(const bluetooth_device_address_t *address)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GError *error = NULL;
char address_string[18] = { 0, };
char *ptr = NULL;
_bt_convert_addr_type_to_string(address_string, (unsigned char *)address->addr);
BT_DBG("Address String: %s", address_string);
- dbus_connection = _bt_get_session_gconn();
- if (dbus_connection == NULL) {
- BT_ERR("Couldn't connect to system bus");
+ g_conn = _bt_gdbus_get_session_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("Couldn't connect to session bus");
return EXIT_FAILURE;
}
-
- g_pbap_proxy = g_dbus_proxy_new_sync(dbus_connection,
+ g_pbap_proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
PBAP_OBEX_CLIENT_SERVICE, PBAP_OBEX_CLIENT_PATH,
PBAP_OBEX_CLIENT_INTERFACE, NULL, &error);
char *address_string = user_data;
GError *error = NULL;
GVariant *value;
+ int result = BLUETOOTH_ERROR_INTERNAL ;
BT_DBG("Address = %s", address_string);
g_free(g_pbap_server_address);
g_pbap_server_address = NULL;
+ result = BLUETOOTH_ERROR_NONE;
selected_path.folder = -1;
selected_path.type = -1;
+
+ g_variant_unref(value);
}
- /* PBAP disconnected event will be sent in event reciever */
+ /* If the result is success, the event reciever will send the disconnect event */
+ if (result != BLUETOOTH_ERROR_NONE) {
+ GVariant *signal = NULL;
+
+ signal = g_variant_new("(is)", result, address_string);
+ _bt_send_event(BT_PBAP_CLIENT_EVENT,
+ BLUETOOTH_PBAP_DISCONNECTED,
+ signal);
+ }
g_free(address_string);
BT_DBG("-");
transfer_info->filename = (char *)filename;
transfer_info->operation = PULL_ALL;
transfers = g_slist_append(transfers, transfer_info);
+
+ g_variant_unref(value);
}
g_object_unref(proxy);
}
BT_DBG("Address = %s", address_string);
- GVariant *temp = g_variant_new_strv((const gchar*)vcard_list, length);
+ GVariant *temp = g_variant_new_strv((const gchar * const *)vcard_list, length);
signal = g_variant_new("(isv)", result, address_string, temp);
_bt_send_event(BT_PBAP_CLIENT_EVENT,
BT_DBG("Address = %s", address_string);
signal = g_variant_new("(is@as)", result, address_string,
- g_variant_new_strv((const gchar *)vcard_list, length));
+ g_variant_new_strv((const gchar * const *)vcard_list, length));
_bt_send_event(BT_PBAP_CLIENT_EVENT,
BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
g_free(format_str);
g_free(order_str);
+ g_free(target_file);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
char *target_file = NULL;
char *download_path = NULL;
char *vcard_handle = NULL;
- char vcard[10] = { 0, };
+ char vcard[20] = { 0, };
GVariantBuilder builder;
GVariantBuilder inner_builder;
GVariant *filters;
g_free(format_str);
g_free(vcard_handle);
+ g_free(target_file);
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
return BLUETOOTH_ERROR_NONE;
}
+int _bt_pbap_is_connected(bluetooth_device_address_t *device_address,
+ gboolean *connected)
+{
+ char address_string[18] = { 0, };
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_PARAMETER(connected, return);
+
+ /* In now, only 1 pbap connection is allowed */
+ if (g_pbap_server_address == NULL) {
+ *connected = FALSE;
+ return 0;
+ }
+
+ _bt_convert_addr_type_to_string(address_string,
+ (unsigned char *)device_address->addr);
+ BT_DBG("Address String: %s", address_string);
+
+ if (g_strcmp0(address_string, g_pbap_server_address) == 0)
+ *connected = TRUE;
+ else
+ *connected = FALSE;
+
+ return 0;
+}
+
int _bt_pbap_get_phonebook_size(const bluetooth_device_address_t *address,
int source, int type)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GDBusProxy *g_pbap_session_proxy = NULL;
char address_string[18] = { 0, };
char *source_string = NULL;
BT_DBG("Address[%s] Source[%s] Type[%s]",
address_string, source_string, type_string);
BT_DBG("Session Path = %s\n", g_pbap_session_path);
- g_pbap_session_proxy = g_dbus_proxy_new_sync(dbus_connection,
+
+ g_conn = _bt_gdbus_get_session_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("Couldn't connect to session bus");
+ g_free(source_string);
+ g_free(type_string);
+ return 0;
+ }
+ g_pbap_session_proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
PBAP_SESSION_SERVICE, g_pbap_session_path,
PBAP_SESSION_INTERFACE, NULL, &err);
int source, int type, bt_pbap_pull_parameters_t *app_param)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GDBusProxy *g_pbap_session_proxy = NULL;
char address_string[18] = { 0, };
char *source_string = NULL;
address_string, source_string, type_string);
BT_DBG("Session Path = %s\n", g_pbap_session_path);
- g_pbap_session_proxy = g_dbus_proxy_new_sync(dbus_connection,
+
+ g_conn = _bt_gdbus_get_session_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("Couldn't connect to session bus");
+ g_free(source_string);
+ g_free(type_string);
+ return 0;
+ }
+ g_pbap_session_proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
PBAP_SESSION_SERVICE, g_pbap_session_path,
PBAP_SESSION_INTERFACE, NULL, &err);
pbap_data->app_param = param;
if (source == selected_path.folder && type == selected_path.type) {
+ g_free(source_string);
+ g_free(type_string);
return __bt_pbap_call_get_phonebook(g_pbap_session_proxy, pbap_data);
}
int type, bt_pbap_list_parameters_t *app_param)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GDBusProxy *g_pbap_session_proxy = NULL;
char address_string[18] = { 0, };
char *source_string = NULL;
address_string, source_string, type_string);
BT_DBG("Session Path = %s\n", g_pbap_session_path);
- g_pbap_session_proxy = g_dbus_proxy_new_sync(dbus_connection,
+
+ g_conn = _bt_gdbus_get_session_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("Couldn't connect to session bus");
+ g_free(source_string);
+ g_free(type_string);
+ return 0;
+ }
+ g_pbap_session_proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
PBAP_SESSION_SERVICE, g_pbap_session_path,
PBAP_SESSION_INTERFACE, NULL, &err);
int source, int type, bt_pbap_pull_vcard_parameters_t *app_param)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GDBusProxy *g_pbap_session_proxy = NULL;
char address_string[18] = { 0, };
char *source_string = NULL;
address_string, source_string, type_string);
BT_DBG("Session Path = %s\n", g_pbap_session_path);
- g_pbap_session_proxy = g_dbus_proxy_new_sync(dbus_connection,
+
+ g_conn = _bt_gdbus_get_session_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("Couldn't connect to session bus");
+ g_free(source_string);
+ g_free(type_string);
+ return 0;
+ }
+ g_pbap_session_proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
PBAP_SESSION_SERVICE, g_pbap_session_path,
PBAP_SESSION_INTERFACE, NULL, &err);
ERR("Unable to create proxy: %s", err->message);
g_clear_error(&err);
}
+ g_free(source_string);
+ g_free(type_string);
return -1;
}
pbap_data->app_param = param;
if (source == selected_path.folder && type == selected_path.type) {
+ g_free(source_string);
+ g_free(type_string);
return __bt_pbap_call_get_vcard(g_pbap_session_proxy, pbap_data);
}
int source, int type, bt_pbap_search_parameters_t *app_param)
{
BT_DBG("+");
+ GDBusConnection *g_conn;
GDBusProxy *g_pbap_session_proxy = NULL;
char address_string[18] = { 0, };
char *source_string = NULL;
BT_DBG("Session Path = %s\n", g_pbap_session_path);
- g_pbap_session_proxy = g_dbus_proxy_new_sync(dbus_connection,
+ g_conn = _bt_gdbus_get_session_gconn();
+ if (g_conn == NULL) {
+ BT_ERR("Couldn't connect to session bus");
+ g_free(source_string);
+ g_free(type_string);
+ return 0;
+ }
+ g_pbap_session_proxy = g_dbus_proxy_new_sync(g_conn,
G_DBUS_PROXY_FLAGS_NONE, NULL,
PBAP_SESSION_SERVICE, g_pbap_session_path,
PBAP_SESSION_INTERFACE, NULL, &err);
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <dlog.h>
+#include <string.h>
+#include <syspopup_caller.h>
+#include <vconf.h>
+#include <bundle_internal.h>
+
+#include "bluetooth-api.h"
+#include "bt-internal-types.h"
+
+#include "bt-service-common.h"
+#include "bt-service-device.h"
+#include "bt-service-proximity.h"
+
+char *_bt_convert_alert_level_to_string(int value)
+{
+ if (value == BT_PXP_ALERT_MILD)
+ return g_strdup("mild");
+ else if (value == BT_PXP_ALERT_HIGH)
+ return g_strdup("high");
+ else
+ return g_strdup("none");
+}
+
+int _bt_convert_string_to_alert_level(const char *str)
+{
+ if (g_strcmp0("high", str) == 0)
+ return BT_PXP_ALERT_HIGH;
+ else if (g_strcmp0("mild", str) == 0)
+ return BT_PXP_ALERT_MILD;
+
+ return BT_PXP_ALERT_NONE;
+}
+
+char *_bt_convert_property_to_string(int value)
+{
+ if (value == BT_PXP_PROPERTY_LLS)
+ return g_strdup("LinkLossAlertLevel");
+ else if (value == BT_PXP_PROPERTY_IAS)
+ return g_strdup("ImmediateAlertLevel");
+ else if (value == BT_PXP_PROPERTY_TX_POWER)
+ return g_strdup("SignalLevel");
+
+ return NULL;
+}
+
+int bt_set_proximity_property(bluetooth_device_address_t *device_address,
+ unsigned int property, int alert_level)
+{
+ GDBusProxy *proxy;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ GDBusConnection *conn;
+ char *device_path = NULL;
+ GError *error = NULL;
+ GVariant *ret = NULL;
+ char *value_str = NULL;
+ char *property_str = NULL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ device_path = _bt_get_device_object_path(address);
+
+ if (device_path == NULL) {
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ } else {
+ BT_INFO("device_path is created[%s]", device_path);
+ }
+
+ value_str = _bt_convert_alert_level_to_string(alert_level);
+ property_str =_bt_convert_property_to_string(property);
+
+ if (value_str == NULL || property_str == NULL) {
+ g_free(property_str);
+ g_free(value_str);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ ret = g_dbus_proxy_call_sync(proxy, "Set",
+ g_variant_new("(ssv)", BT_PROXIMITY_MONITOR_INTERFACE, property_str, g_variant_new("s", value_str)),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (ret)
+ g_variant_unref(ret);
+ g_object_unref(proxy);
+ g_free(property_str);
+ g_free(value_str);
+
+ if (error) {
+ BT_ERR("SetProperty error: [%s]", error->message);
+ g_error_free(error);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int bt_get_proximity_property(bluetooth_device_address_t *device_address,
+ unsigned int property, int *alert_level)
+{
+ GDBusProxy *proxy;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GDBusConnection *conn;
+ char *device_path = NULL;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GVariant *tmp_value;
+ GVariant *value;
+ char *value_str = NULL;
+ char *property_str = NULL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ device_path = _bt_get_device_object_path(address);
+
+ if (device_path == NULL) {
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ } else {
+ BT_INFO("device_path is created[%s]", device_path);
+ }
+
+ property_str = _bt_convert_property_to_string(property);
+
+ if (property_str == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(proxy, "GetAll",
+ g_variant_new("(s)", BT_PROXIMITY_MONITOR_INTERFACE),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (result == NULL) {
+ if (error != NULL) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ g_variant_get(result , "(@a{sv})", &value);
+ g_variant_unref(result);
+
+ tmp_value = g_variant_lookup_value(value, property_str, G_VARIANT_TYPE_STRING);
+ if (tmp_value == NULL) {
+ g_object_unref(proxy);
+ g_variant_unref(value);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ value_str = (char *)g_variant_get_string(tmp_value, NULL);
+ if (value_str)
+ *alert_level = _bt_convert_string_to_alert_level(value_str);
+
+ g_variant_unref(tmp_value);
+ g_variant_unref(value);
+ g_object_unref(proxy);
+ g_free(property_str);
+ g_free(value_str);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int bt_get_proximity_supported_services(bluetooth_device_address_t *device_address,
+ unsigned int *supported_services)
+{
+ GDBusProxy *proxy;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ GDBusConnection *conn;
+ char *device_path = NULL;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GVariant *tmp_value;
+ GVariant *value;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ device_path = _bt_get_device_object_path(address);
+
+ if (device_path == NULL) {
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ } else {
+ BT_INFO("device_path is created[%s]", device_path);
+ }
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(proxy, "GetAll",
+ g_variant_new("(s)", BT_PROXIMITY_MONITOR_INTERFACE),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (result == NULL) {
+ if (error != NULL) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ g_variant_get(result , "(@a{sv})", &value);
+ g_variant_unref(result);
+
+ *supported_services = 0;
+ tmp_value = g_variant_lookup_value(value, "LinkLossAlertLevel", G_VARIANT_TYPE_STRING);
+ if (tmp_value == NULL) {
+ g_object_unref(proxy);
+ g_variant_unref(value);
+ return BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ *supported_services |= BT_PXP_PROPERTY_LLS;
+ g_variant_unref(tmp_value);
+ }
+
+ tmp_value = g_variant_lookup_value(value, "ImmediateAlertLevel", G_VARIANT_TYPE_STRING);
+ if (tmp_value == NULL) {
+ if (*supported_services == 0) {
+ g_object_unref(proxy);
+ g_variant_unref(value);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ } else {
+ *supported_services |= BT_PXP_PROPERTY_IAS;
+ g_variant_unref(tmp_value);
+ }
+
+ tmp_value = g_variant_lookup_value(value, "SignalLevel", G_VARIANT_TYPE_STRING);
+ if (tmp_value == NULL) {
+ if (*supported_services == 0) {
+ g_object_unref(proxy);
+ g_variant_unref(value);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ } else {
+ *supported_services |= BT_PXP_PROPERTY_TX_POWER;
+ g_variant_unref(tmp_value);
+ }
+
+ g_variant_unref(value);
+ g_object_unref(proxy);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int bt_register_proximity_reporter()
+{
+ GDBusProxy *proxy;
+
+ GDBusConnection *conn;
+ char *adapter_path = NULL;
+ GError *error = NULL;
+ GVariant *result = NULL;
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ adapter_path = _bt_get_adapter_path();
+ if (adapter_path == NULL) {
+ BT_ERR("Could not get adapter path\n");
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ BT_INFO("Adapter path %s", adapter_path);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, adapter_path,
+ BT_PROXIMITY_REPORTER_INTERFACE, NULL, NULL);
+
+ g_free(adapter_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(proxy, "RegisterProximity",
+ NULL, G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ if (result == NULL) {
+ if (error != NULL) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ g_object_unref(proxy);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int bt_unregister_proximity_reporter()
+{
+ GDBusProxy *proxy;
+
+ GDBusConnection *conn;
+ char *adapter_path = NULL;
+ GError *error = NULL;
+ GVariant *result = NULL;
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ adapter_path = _bt_get_adapter_path();
+ if (adapter_path == NULL) {
+ BT_ERR("Could not get adapter path\n");
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ BT_INFO("Adapter path %s", adapter_path);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, adapter_path,
+ BT_PROXIMITY_REPORTER_INTERFACE, NULL, NULL);
+
+ g_free(adapter_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(proxy, "UnregisterProximity",
+ NULL, G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ if (result == NULL) {
+ if (error != NULL) {
+ BT_ERR("Error occured in Proxy call [%s]\n", error->message);
+ g_error_free(error);
+ }
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ g_object_unref(proxy);
+
+ return BLUETOOTH_ERROR_NONE;
+}
{
BT_CHECK_PARAMETER(existence, return);
- if (server_list && g_slist_length(server_list) > 0) {
+ if (server_list && g_slist_length(server_list) > 0)
*existence = TRUE;
- } else {
+ else
*existence = FALSE;
- }
return BLUETOOTH_ERROR_NONE;
}
if (server_info == NULL)
continue;
- if (g_strcmp0(server_info->sender, name) == 0) {
+ if (g_strcmp0(server_info->sender, name) == 0)
_bt_rfcomm_remove_socket(server_info->control_fd);
- }
+
}
return BLUETOOTH_ERROR_NONE;
typedef struct {
char *addr;
+ int addr_type;
+ int rssi;
int data_len;
char *data;
+ guint timer_id;
} bt_le_adv_info_t;
int _bt_service_adapter_le_init(void);
int _bt_set_custom_advertising(const char *sender, int adv_handle, gboolean enable, bluetooth_advertising_params_t *params, gboolean use_reserved_slot);
+int _bt_hold_current_advertising(void);
+
int _bt_get_advertising_data(bluetooth_advertising_data_t *adv, int *length);
int _bt_set_advertising_data(const char *sender, int adv_handle, bluetooth_advertising_data_t *data, int length, gboolean use_reserved_slot);
int _bt_set_scan_parameters(bluetooth_le_scan_params_t *params);
+gboolean _bt_is_scan_filter_supported(void);
+
int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id);
int _bt_unregister_scan_filter(const char *sender, int slot_id);
void _bt_send_scan_result_event(const bt_remote_le_dev_info_t *le_dev_info, const bt_le_adv_info_t *adv_info);
+void _bt_send_ibeacon_scan_result_event(const bt_remote_ibeacon_dev_info_t *ibeacon_dev_info);
+
int _bt_add_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type);
int _bt_remove_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type);
gboolean _bt_is_set_scan_parameter(void);
-void _bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id);
-
void _bt_unregister_adv_slot_owner(int slot_id);
#ifdef __cplusplus
#include <glib.h>
#include <sys/types.h>
#include "bluetooth-api.h"
+#include "alarm.h"
#ifdef __cplusplus
extern "C" {
BT_LE_DEACTIVATING,
} bt_le_status_t;
+int _bt_adapter_request_delayed(int function);
+
+int _bt_enable_adapter_check_status(void);
+
int _bt_enable_adapter(void);
+int _bt_disable_adapter_check_status(void);
+
+void _bt_keep_bt_status_vconf(void);
+
int _bt_disable_adapter(void);
int _bt_recover_adapter(void);
int _bt_reset_adapter(void);
+void _bt_set_bluetooth_status(void);
+
int _bt_enable_core(void);
void _bt_handle_adapter_added(void);
void _bt_service_unregister_vconf_handler(void);
+gboolean _bt_is_deactivated_by_flight_ps_mode(void);
+
void _bt_set_discovery_status(gboolean mode);
int _bt_get_local_address(bluetooth_device_address_t *local_address);
int _bt_get_bonded_devices(GArray **dev_list);
+int _bt_get_profile_connected_devices(char *profile_uuid, GArray **addr_list);
+
int _bt_get_bonded_device_info(bluetooth_device_address_t *device_address,
bluetooth_device_info_t *dev_info);
+int _bt_is_alias_set(bluetooth_device_address_t *device_address, gboolean *is_alias_set);
+
int _bt_get_timeout_value(int *timeout);
gboolean _bt_is_discovering(void);
bt_le_status_t _bt_adapter_get_le_status(void);
+void _bt_adapter_set_vconf_status(gboolean enable);
+
+void _bt_set_booting_time_flag(gboolean flag);
+
+void _bt_set_le_intended_status(gboolean value);
+
void _bt_adapter_start_enable_timer(void);
void _bt_adapter_start_le_enable_timer(void);
int _bt_set_le_privacy(gboolean set_privacy);
+int _bt_set_le_static_random_address(gboolean is_enable);
+
int _bt_set_manufacturer_data(bluetooth_manufacturer_data_t *m_data);
-int __bt_disable_cb(void);
+void _bt_start_log_dump(const char *path);
+
+int _bt_disable_cb(void);
int _bt_get_enable_timer_id(void);
+void _bt_force_hci_dump(int timeout);
+
+typedef int (*bt_set_alarm_cb) (alarm_id_t alarm_id, void* user_param);
+
+int _bt_service_set_alarm(int timeout, bt_set_alarm_cb call_back,
+ void *user_data, alarm_id_t *alarm_id);
+
+int _bt_service_remove_alarm(alarm_id_t alarm_id);
+
+gint compare_alarm(gconstpointer list_data, gconstpointer data);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#define BT_MAX_EVENT_STR_LENGTH 50
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#define BT_FILE_VISIBLE_TIME "file/private/libug-setting-bluetooth-efl/visibility_time"
#endif
int _bt_launch_system_popup(bt_agent_event_type_t event_type,
const char *device_name,
+ const unsigned char *auth_info,
char *passkey,
const char *filename,
const char *agent_path);
+
+int _bt_set_passkey_notification(const char *sender, gboolean enable);
+
#endif
int disconnection_type;
char *address;
gboolean ag_flag;
- GArray **out_param1;
} bt_headset_wait_t;
typedef struct {
int req_id;
char *address;
bt_pending_request_t pending;
- GArray **out_param;
int type;
} bt_audio_function_data_t;
BT_AUDIO_A2DP,
BT_AUDIO_ALL,
BT_AVRCP,
- BT_AUDIO_A2DP_SOURCE
+ BT_AUDIO_A2DP_SOURCE,
+ BT_AVRCP_TARGET
} bt_audio_type_t;
typedef enum {
#define BT_CONTENT_PROTECTION_PATH "/org/tizen/bluetooth/a2dpcontentprotection"
#define BT_CONTENT_PROTECTION_INTERFACE "org.tizen.bluetooth.A2dpContentProtection"
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+#define BT_AUTO_CONNECT_TIMEOUT_AFTER_BT_ACTIVATED 2 /* 2 sec */
+#define BT_AUTO_CONNECT_TIMEOUT_AFTER_LINKLOSS 30 /* 30 sec */
+#define BT_AUTO_CONNECT_TIMEOUT_RETRY_TIME 3600 /* 60 minute */
+#endif
+
int _bt_audio_connect(int request_id, int type,
bluetooth_device_address_t *device_address,
- GArray **out_param1);
+ GArray *out_param1);
int _bt_audio_disconnect(int request_id, int type,
bluetooth_device_address_t *device_address,
- GArray **out_param1);
+ GArray *out_param1);
int _bt_hf_connect(int request_id,
bluetooth_device_address_t *device_address,
- GArray **out_param1);
+ GArray *out_param1);
int _bt_hf_disconnect(int request_id,
bluetooth_device_address_t *device_address,
- GArray **out_param1);
+ GArray *out_param1);
int _bt_audio_get_speaker_gain(unsigned int *gain);
gboolean _bt_is_service_connected(char *address, int type);
+#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
+int _bt_audio_start_auto_connect(gboolean linkloss_flag);
+
+int _bt_audio_stop_auto_connect(void);
+
+void _bt_audio_set_auto_connect_device_addr(const char *address);
+#endif
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
#define LOG_COLOR_BLUE "\033[36m"
#define LOG_COLOR_PURPLE "\033[35m"
+
+#ifndef TIZEN_TV
+#define BT_DBG(fmt, args...) \
+ SLOGD(fmt, ##args)
+#define BT_INFO(fmt, args...) \
+ SLOGI(fmt, ##args)
+#define BT_ERR(fmt, args...) \
+ SLOGE(fmt, ##args)
+#else
#define BT_DBG(fmt, args...) \
- SLOGD(fmt, ##args)
+ LOGI(fmt, ##args)
#define BT_INFO(fmt, args...) \
- SLOGI(fmt, ##args)
+ LOGI(fmt, ##args)
#define BT_ERR(fmt, args...) \
- SLOGE(fmt, ##args)
+ LOGE(fmt, ##args)
+#endif
#define BT_INFO_C(fmt, arg...) \
SLOGI_IF(TRUE, LOG_COLOR_GREEN" "fmt" "LOG_COLOR_RESET, ##arg)
SLOGI_IF(TRUE, LOG_COLOR_RED" "fmt" "LOG_COLOR_RESET, ##arg)
#define DBG_SECURE(fmt, args...) SECURE_SLOGD(fmt, ##args)
+#define INFO_SECURE(fmt, args...) SECURE_SLOGI(fmt, ##args)
#define ERR_SECURE(fmt, args...) SECURE_SLOGE(fmt, ##args)
#define ret_if(expr) \
#endif
#define BT_DISCOVERY_FINISHED_DELAY 200
+#define BT_SESSION_BUS_GET_TIMEOUT 200 /* 200 ms */
+
#define MANAGER_EVENT_MATCH_RULE \
"type='signal'," \
"interface='%s'," \
"the reply timeout expired, or the network connection " \
"was broken."
+#define BT_DBUS_TIMEOUT_MESSAGE "Timeout was reached"
+
#define BT_BLUEZ_NAME "org.bluez"
#define BT_BLUEZ_PATH "/org/bluez"
#define BT_OBEXD_MANAGER_INTERFACE "org.openobex.Manager"
#define BT_OBEXD_TRANSFER_INTERFACE "org.openobex.Transfer"
#define BT_A2DP_SOURCE_INTERFACE "org.bluez.AudioSource"
+#define BT_PROXIMITY_MONITOR_INTERFACE "org.bluez.ProximityMonitor1"
+#define BT_PROXIMITY_REPORTER_INTERFACE "org.bluez.ProximityReporter1"
#define BT_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties"
-
#define BT_OBEX_SERVICE_NAME "org.bluez.obex"
#define BT_OBEX_CLIENT_PATH "/org/bluez/obex"
#define BT_OBEX_CLIENT_INTERFACE "org.bluez.obex.Client1"
#define BT_FREEDESKTOP_PATH "/org/freedesktop/DBus"
+#define BT_DUMP_SERVICE_NAME "org.tizen.system.dumpservice"
+#define BT_DUMP_SERVICE_PATH "/Org/Tizen/System/DumpService"
+#define BT_DUMP_SERVICE_INTERFACE BT_DUMP_SERVICE_NAME
+
+#define BT_DUMP_SERVICE_SIGNAL "Dump"
+#define BT_DUMP_SERVICE_START_SIGNAL "Start"
+#define BT_DUMP_SERVICE_FINISH_SIGNAL "Finish"
+
+
#define BT_INTERFACES_ADDED "InterfacesAdded"
#define BT_INTERFACES_REMOVED "InterfacesRemoved"
#define BT_NAME_OWNER_CHANGED "NameOwnerChanged"
/* UUID */
#define GENERIC_AUDIO_UUID "00001203-0000-1000-8000-00805f9b34fb"
-#define OBEX_OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
-
-#define HSP_HS_UUID "00001108-0000-1000-8000-00805f9b34fb"
-#define HSP_AG_UUID "00001112-0000-1000-8000-00805f9b34fb"
+#define AVRCP_TARGET_UUID "0000110c-0000-1000-8000-00805f9b34fb"
+#define AVRCP_REMOTE_UUID "0000110e-0000-1000-8000-00805f9b34fb"
+#define ADVANCED_AUDIO_UUID "0000110d-0000-1000-8000-00805f9b34fb"
+#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
+#define A2DP_SOURCE_UUID "0000110a-0000-1000-8000-00805f9b34fb"
#define HFP_HS_UUID "0000111e-0000-1000-8000-00805f9b34fb"
#define HFP_AG_UUID "0000111f-0000-1000-8000-00805f9b34fb"
-#define ADVANCED_AUDIO_UUID "0000110d-0000-1000-8000-00805f9b34fb"
-
-#define A2DP_SOURCE_UUID "0000110a-0000-1000-8000-00805f9b34fb"
-#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
-
-#define AVRCP_REMOTE_UUID "0000110e-0000-1000-8000-00805f9b34fb"
-#define AVRCP_TARGET_UUID "0000110c-0000-1000-8000-00805f9b34fb"
+#define HSP_HS_UUID "00001108-0000-1000-8000-00805f9b34fb"
+#define HSP_AG_UUID "00001112-0000-1000-8000-00805f9b34fb"
+#define RFCOMM_UUID_STR "00000003-0000-1000-8000-00805f9b34fb"
+#define HID_DEVICE_UUID "00001124-0000-1000-8000-00805f9b43bf"
#define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
+#define PANU_UUID "00001115-0000-1000-8000-00805f9b34fb"
+#define NAP_UUID "00001116-0000-1000-8000-00805f9b34fb"
#define PNP_UUID "00001200-0000-1000-8000-00805f9b34fb"
-#define RFCOMM_UUID_STR "00000003-0000-1000-8000-00805f9b34fb"
-#define PANU_UUID "00001115-0000-1000-8000-00805f9b34fb"
-#define NAP_UUID "00001116-0000-1000-8000-00805f9b34fb"
-#define OBEX_PSE_UUID "0000112f-0000-1000-8000-00805f9b34fb"
-#define GATT_UUID "00001801-0000-1000-8000-00805f9b34fb"
+#define PBAP_UUID "0000112f-0000-1000-8000-00805f9b34fb"
+
+#define OBEX_OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
+#define OBEX_PSE_UUID "0000112f-0000-1000-8000-00805f9b34fb"
+
+#define GATT_UUID "00001801-0000-1000-8000-00805f9b34fb"
/* Privilege */
#define BT_PRIVILEGE_PUBLIC "http://tizen.org/privilege/bluetooth"
BT_PROFILE_CONN_GATT = 0x40,
BT_PROGILE_CONN_NAP = 0x80,
BT_PROFILE_CONN_A2DP_SINK = 0x100,
+ BT_PROFILE_CONN_PBAP = 0x200,
BT_PROFILE_CONN_ALL = 0xffffffff,
} bt_profile_type_t;
} bt_remote_le_dev_info_t;
typedef struct {
+ char *address;
+ int addr_type;
+ int rssi;
+ int adv_type;
+ int company_id;
+ int ibeacon_type;
+ int major_id;
+ int minor_id;
+ int measured_power;
+ char *uuid;
+} bt_remote_ibeacon_dev_info_t;
+
+typedef struct {
int rssi;
int class;
char *address;
gboolean paired;
bluetooth_connected_link_t connected;
gboolean trust;
+ gboolean is_alias_set;
char *manufacturer_data;
int manufacturer_data_len;
guchar addr_type;
char *address;
} bt_function_data_t;
-GDBusConnection *_bt_get_system_conn(void);
+GDBusConnection *_bt_gdbus_get_system_gconn(void);
-GDBusConnection *_bt_get_system_gconn(void);
-
-GDBusConnection *_bt_get_session_gconn(void);
+GDBusConnection *_bt_gdbus_get_session_gconn(void);
void *_bt_get_net_conn(void);
void _bt_convert_addr_string_to_type(unsigned char *addr,
const char *address);
+void _bt_convert_addr_string_to_secure_string(char *addr,
+ const char *address);
+
void _bt_convert_addr_type_to_string(char *address,
unsigned char *addr);
int _bt_eventsystem_set_value(const char *event, const char *key, const char *value);
+void __bt_get_auth_info(GVariant *reply, char *auth_info);
+
+int _bt_convert_gerror(GError *g_error);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
bt_remote_dev_info_t *_bt_get_remote_device_info(char *address);
+bt_remote_dev_info_t *_bt_get_remote_device_info_by_object_path(const char *object_path);
+
char *_bt_get_bonded_device_name(char *address);
gboolean _bt_is_bonding_device_address(const char *address);
-int _bt_connect_le_device(int request_id,
- const bluetooth_device_address_t *bd_addr,
+void _bt_pending_connect_le_device(void);
+
+int _bt_connect_le_device(int req_id, const bluetooth_device_address_t *bd_addr,
gboolean auto_connect);
-int _bt_disconnect_le_device(int request_id,
+int _bt_disconnect_le_device(int req_id,
const bluetooth_device_address_t *bd_addr);
int _bt_le_conn_update(unsigned char *device_address,
- guint16 interval_min, guint16 interval_max,
+ float interval_min, float interval_max,
guint16 latency, guint16 time_out);
int _bt_get_le_connection_parameter(bluetooth_le_connection_mode_t mode,
int _bt_disconnect_profile(char *address, char *uuid,
void *cb, gpointer func_data);
+
+int _bt_request_att_mtu(int request_id, bluetooth_device_address_t *device_address,
+ unsigned int mtu);
+
+int _bt_get_att_mtu(bluetooth_device_address_t *device_address,
+ unsigned int *mtu);
+
+int _bt_get_device_ida(bluetooth_device_address_t *device_address,
+ bluetooth_device_address_t *id_address);
+
+int _bt_set_trust_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_trusted_profile_t profile, gboolean trust);
+
+int _bt_get_trust_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_trusted_profile_t profile, guint *trust);
+
+int _bt_set_restrict_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_restricted_profile_t profile, gboolean restricted);
+
+int _bt_get_restrict_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_restricted_profile_t profile, guint *restricted);
+
+bluetooth_trusted_profile_t _bt_get_trusted_profile_enum(const char *uuid);
+
int _bt_connect_le_ipsp_device(const bluetooth_device_address_t *bd_addr);
int _bt_disconnect_le_ipsp_device(const bluetooth_device_address_t *bd_addr);
#include "bluetooth-api.h"
#ifdef __cplusplus
- extern "C" {
+extern "C" {
#endif
* @brief DPM BT allowance state
* @see
*/
- typedef enum {
- DPM_BT_ERROR = -1, /**< bluetooth allowance error */
- DPM_BT_ALLOWED, /**< bluetooth allowance allowed */
- DPM_BT_HANDSFREE_ONLY, /**< bluetooth allowance handsfree only */
- DPM_BT_RESTRICTED, /**< bluetooth allowance restricted */
- } dpm_bt_allow_t;
+typedef enum {
+ DPM_BT_ERROR = -1, /**< bluetooth allowance error */
+ DPM_BT_ALLOWED, /**< bluetooth allowance allowed */
+ DPM_BT_HANDSFREE_ONLY, /**< bluetooth allowance handsfree only */
+ DPM_BT_RESTRICTED, /**< bluetooth allowance restricted */
+} dpm_bt_allow_t;
/**
* @brief DPM API result
int _bt_init_hf_local_term_event_sender(void);
void _bt_deinit_hf_local_term_event_sender(void);
+int _bt_send_dump_signal(char *signal);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
struct _GapAgentPrivate {
gchar *busname;
gchar *path;
- GDBusProxy *adapter;
GDBusProxy *agent_manager;
GapAgentExecType exec_type;
GDBusMethodInvocation *reply_context;
+ char *uuid;
char pairing_addr[18];
char authorize_addr[18];
int _bt_hid_disconnect(int request_id,
bluetooth_device_address_t *device_address);
+int _bt_hid_enable_barcode_feature(void);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
gboolean _bt_reliable_terminate_service(gpointer user_data);
+int _bt_service_initialize(void);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
int _bt_obex_server_reject_connection(void);
+int _bt_opp_get_server_progress(int transfer_id, guint8 *progress);
+
int _bt_obex_server_is_receiving(gboolean *receiving);
void _bt_obex_transfer_progress(const char *transfer_path,
- int transferred);
+ guint64 transferred);
void _bt_obex_transfer_completed(const char *transfer_path, gboolean success);
void _bt_obex_transfer_started(const char *transfer_path);
void _bt_obex_check_pending_transfer(const char *address);
-void _bt_obex_transfer_connected(void);
+void _bt_obex_transfer_connected(const char *obj_path);
-void _bt_obex_transfer_disconnected(void);
+void _bt_obex_transfer_disconnected(char *address);
int _bt_obex_get_native_pid(void);
+void _bt_obex_server_reply_accept(void);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
char *transfer_path;
bt_transfer_status_t transfer_status;
gint64 size;
+ guint64 progress;
} bt_transfer_info_t;
typedef struct {
void _bt_opc_disconnected(const char *session_path);
-gboolean _bt_obex_client_progress(const char *transfer_path, int transferred);
+gboolean _bt_obex_client_progress(const char *transfer_path, guint64 transferred);
gboolean _bt_obex_client_started(const char *transfer_path);
void _bt_opp_client_check_pending_transfer(const char *address);
+int _bt_opp_get_client_progress(guint8 *progress);
+
+void _bt_cancel_queued_transfers(void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
int _bt_pbap_disconnect(const bluetooth_device_address_t *address);
+int _bt_pbap_is_connected(bluetooth_device_address_t *device_address,
+ gboolean *connected);
+
int _bt_pbap_get_phonebook_size(const bluetooth_device_address_t *address,
int source, int type);
--- /dev/null
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_SERVICE_PROXIMITY_H_
+#define _BT_SERVICE_PROXIMITY_H_
+
+#include <glib.h>
+#include <sys/types.h>
+#include "bluetooth-api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef enum {
+ BT_PXP_ALERT_NONE = 0,
+ BT_PXP_ALERT_MILD,
+ BT_PXP_ALERT_HIGH
+} bt_proximity_alert_value_t;
+
+typedef enum {
+ BT_PXP_PROPERTY_LLS = 0x01,
+ BT_PXP_PROPERTY_IAS = 0x02,
+ BT_PXP_PROPERTY_TX_POWER = 0x04
+} bt_proximity_alert_property_t;
+
+typedef enum {
+ BT_PXP_REPORTER_ROLE = 0x00,
+ BT_PXP_MONITOR_ROLE = 0x01,
+} bt_proximity_role_t;
+
+int bt_set_proximity_property(bluetooth_device_address_t *device_address,
+ unsigned int property, int value);
+
+int bt_get_proximity_property(bluetooth_device_address_t *device_address,
+ unsigned int property, int *value);
+
+int bt_get_proximity_supported_services(bluetooth_device_address_t *device_address,
+ unsigned int *supported_services);
+
+int bt_register_proximity_reporter();
+
+int bt_unregister_proximity_reporter();
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_SERVICE_PROXIMITY_H_*/
* @{
*/
-#define BLUETOOTH_ADDRESS_LENGTH 6 /**< This specifies bluetooth device address length */
-#define BLUETOOTH_VERSION_LENGTH_MAX 30 /**< This specifies bluetooth device version length */
-#define BLUETOOTH_INTERFACE_NAME_LENGTH 16
-#define BLUETOOTH_DEVICE_NAME_LENGTH_MAX 248 /**< This specifies maximum device name length */
+#define BLUETOOTH_ADDRESS_LENGTH 6 /**< This specifies bluetooth device address length */
+#define BLUETOOTH_VERSION_LENGTH_MAX 30 /**< This specifies bluetooth device version length */
+#define BLUETOOTH_INTERFACE_NAME_LENGTH 16
+#define BLUETOOTH_DEVICE_NAME_LENGTH_MAX 248 /**< This specifies maximum device name length */
#define BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX 50 /**< This specifies maximum length of the passkey */
#define BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX 31 /**< This specifies maximum AD data length */
-#define BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX 31 /**< This specifies maximum LE Scan response data length */
+#define BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX 31 /**< This specifies maximum LE Scan response data length */
#define BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX 240 /**< This specifies maximum manufacturer data length */
-#define BLUETOOTH_MAX_SERVICES_FOR_DEVICE 40 /**< This specifies maximum number of services
+#define BLUETOOTH_MAX_SERVICES_FOR_DEVICE 40 /**< This specifies maximum number of services
a device can support */
+#define BLUETOOTH_MAX_ATT_MTU 512 /**< This specifies the maximum ATT MTU Value*/
+
#define BLUETOOTH_UUID_STRING_MAX 50
#define BLUETOOTH_PATH_STRING 50
#define BLUETOOTH_ERROR_NOT_INITIALIZED ((int)BLUETOOTH_ERROR_BASE - 0x26)
/**< Not initialized */
-#define BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION ((int)BLUETOOTH_ERROR_BASE - 0x27)
+#define BLUETOOTH_ERROR_AUTHENTICATION_REJECTED ((int)BLUETOOTH_ERROR_BASE - 0x27)
+ /**< Authentication rejected */
+
+#define BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION ((int)BLUETOOTH_ERROR_BASE - 0x28)
/**< Device Policy Restricted */
/**
+ * Device disconnection reasons; received from stack
+ */
+#define BLUETOOTH_ERROR_PAGE_TIMEOUT 0x04
+#define BLUETOOTH_ERROR_AUTH_FAILURE 0x05
+#define BLUETOOTH_ERROR_PIN_OR_KEY_MISSING 0x06
+#define BLUETOOTH_ERROR_CONNECTION_TIMEOUT 0x08
+#define BLUETOOTH_ERROR_REMOTE_USER_TERM 0x13
+#define BLUETOOTH_ERROR_REMOTE_LOW_RESOURCES 0x14
+#define BLUETOOTH_ERROR_REMOTE_POWER_OFF 0x15
+#define BLUETOOTH_ERROR_LOCAL_HOST_TERM 0x16
+#define BLUETOOTH_ERROR_REPEATED_ATTEMPTS 0x17
+#define BLUETOOTH_ERROR_LMP_RESPONSE_TIMEOUT 0x22
+#define BLUETOOTH_ERROR_CONNECTION_FAILED_TO_BE_ESTABLISHED 0x3e
+
+
+
+/**
* Device disconnect reason
*/
typedef enum {
BLUETOOTH_GATT_SERVICE = 0x40,
BLUETOOTH_NAP_SERVER_SERVICE = 0x80,
BLUETOOTH_A2DP_SINK_SERVICE = 0x100,
+ BLUETOOTH_PBAP_SERVICE = 0x200,
} bluetooth_service_type_t;
/**
* Service type
*/
typedef enum {
- BLUETOOTH_DEV_CONN_DEFAULT = 0xFF, /* represents that connection
- * type can both BR/EDR and LE */
- BLUETOOTH_DEV_CONN_BREDR = 0x00,
- BLUETOOTH_DEV_CONN_LE = 0x01,
+ BLUETOOTH_DEV_CONN_DEFAULT = 0xFF,
+ /* represents that connection
+ * type can both BR/EDR and LE */
+ BLUETOOTH_DEV_CONN_BREDR = 0x00,
+ BLUETOOTH_DEV_CONN_LE = 0x01,
} bluetooth_conn_type_t;
/**
} bluetooth_advertising_type_t;
typedef enum {
+ BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD = 0x01,
+ BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE = 0x02,
+} bluetooth_gatt_service_change_type_t;
+
+typedef enum {
BLUETOOTH_GATT_PERMISSION_READ = 0x01,
BLUETOOTH_GATT_PERMISSION_WRITE = 0x02,
BLUETOOTH_GATT_PERMISSION_ENCRYPT_READ = 0x04,
} bluetooth_gatt_att_request_tyep_t;
/**
+ * Proximity Property Type
+ */
+typedef enum {
+ BLUETOOTH_PXP_PROPERTY_LLS = 0x01, /* Link Loss Alert Proeprty */
+ BLUETOOTH_PXP_PROPERTY_IAS = 0x02, /* Immediate Alert Proeprty */
+ BLUETOOTH_PXP_PROPERTY_TX_POWER = 0x04, /* TX Power */
+} bluetooth_pxp_poperty_t;
+
+/**
* Advertising parameters
*/
typedef struct {
LE Connection Update
*/
typedef struct {
- guint16 interval_min;
- guint16 interval_max;
+ float interval_min;
+ float interval_max;
guint16 latency;
guint16 timeout;
} bluetooth_le_connection_param_t;
char *message;
} bluetooth_vendor_dep_at_cmd_t;
+/**
+ * Transfer Types
+ */
+typedef enum {
+ BLUETOOTH_TRANSFER_INBOUND, /**< Inbound Transfer Type */
+ BLUETOOTH_TRANSFER_OUTBOUND, /**< Outbound Transfer Type */
+} bluetooth_opp_transfer_type_t;
+
+typedef struct {
+ gint event;
+ gint value;
+} bluetooth_hf_ciev_device_event_t;
#define BLUETOOTH_EVENT_BASE ((int)(0x0000)) /**< No event */
#define BLUETOOTH_EVENT_GAP_BASE ((int)(BLUETOOTH_EVENT_BASE + 0x0010))
BLUETOOTH_EVENT_DISCOVERY_FINISHED, /**< Bluetooth event discovery finished */
BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, /**< Bluetooth event remote deice found */
BLUETOOTH_EVENT_LE_DISCOVERY_STARTED, /**< Bluetooth event LE discovery started */
- BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED, /**< Bluetooth event LE discovery finished */
+ BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED, /**< Bluetooth event LE discovery finished */
BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, /**< Bluetooth event remote deice found (LE dev) */
+ BLUETOOTH_EVENT_REMOTE_IBEACON_DEVICE_FOUND, /**< Bluetooth event remote ibeacon device found (iBeacon LE dev) */
BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED,/**< Bluetooth event remote device name updated*/
BLUETOOTH_EVENT_BONDING_FINISHED, /**< Bluetooth event bonding completed */
BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED, /**< Bluetooth event bonding removed */
BLUETOOTH_EVENT_RSSI_ENABLED, /**< Bluetooth event RSSI monitoring enabled */
BLUETOOTH_EVENT_RSSI_ALERT, /**< Bluetooth event RSSI Alert */
BLUETOOTH_EVENT_RAW_RSSI, /**< Bluetooth event Raw RSSI */
+ BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED, /**< Bluetooth event Supported Profile Trusted */
+ BLUETOOTH_EVENT_PASSKEY_NOTIFICATION, /**< Bluetooth event passkey notification */
BLUETOOTH_EVENT_SERVICE_SEARCHED = BLUETOOTH_EVENT_SDP_BASE,
/**< Bluetooth event serice search base id */
BLUETOOTH_EVENT_OPC_CONNECTED = BLUETOOTH_EVENT_OPC_BASE,
/* OPC Connected event */
- BLUETOOTH_EVENT_OPC_DISCONNECTED, /* OPC Disonnected event */
+ BLUETOOTH_EVENT_OPC_DISCONNECTED, /* OPC Disonnected event */
BLUETOOTH_EVENT_OPC_TRANSFER_STARTED, /* OPC Transfer started event */
BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS, /* OPC Transfer progress event */
BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE, /* OPC Transfer Complete event */
BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED, /**<Gatt Char Descriptors Discovered Event*/
BLUETOOTH_EVENT_GATT_CONNECTED,/**<Gatt connected event */
BLUETOOTH_EVENT_GATT_DISCONNECTED, /**<Gatt Disconnected event */
+ BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED, /**<Attribute protocol MTU changed event */
BLUETOOTH_EVENT_GATT_SERVER_CHARACTERISTIC_VALUE_CHANGED, /**<Gatt Char write callback event */
BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED, /** <GATT Characteristic/Descriptor Read Request event */
BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED, /** <GATT Characteristic/Descriptor Value change event */
BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED, /** <GATT Characteristic Notification change event */
BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED, /** <GATT Characteristic Notification or Indication completed event */
+ BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED, /** <GATT Client service change event */
BLUETOOTH_EVENT_AG_CONNECTED = BLUETOOTH_EVENT_AUDIO_BASE, /**<AG service connected event*/
BLUETOOTH_EVENT_AG_DISCONNECTED, /**<AG service disconnected event*/
BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
+ BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
+ BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
+ BLUETOOTH_EVENT_HF_CALL_IDLE,
+ BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
+ BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
+ BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
BLUETOOTH_HID_CONNECTED = BLUETOOTH_EVENT_HID_BASE, /**< Input connectd event*/
BLUETOOTH_HID_DISCONNECTED, /**< Input disconnectd event*/
BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED = BLUETOOTH_EVENT_IPSP_BASE, /**<IPSP init event*/
BLUETOOTH_EVENT_IPSP_CONNECTED, /**< IPSP connected event */
BLUETOOTH_EVENT_IPSP_DISCONNECTED, /**< IPSP Disconnected event */
- BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO, /** IPSP BT Interface Info after connection */
+ BLUETOOTH_EVENT_IPSP_INTERFACE_INFO, /** IPSP BT Interface Info after connection */
BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED, /** LE data length values changed */
+ BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED, /** Proximity property changed */
} bluetooth_event_type_t;
/**
BLUETOOTH_GENERIC_FILE_TRANSFER_UUID = ((unsigned short)0x1202),/**<GENERIC FILE TRANSFER*/
BLUETOOTH_GENERIC_AUDIO_UUID = ((unsigned short)0x1203), /**<GENERIC AUDIO*/
BLUETOOTH_GENERIC_TELEPHONY_UUID = ((unsigned short)0x1204), /**<GENERIC TELEPHONY*/
- BLUETOOTH_VIDEO_SOURCE_UUID = ((unsigned short)0x1303), /**<VEDIO SOURCE*/
+ BLUETOOTH_VIDEO_SOURCE_UUID = ((unsigned short)0x1303), /**<VEDIO SOURCE*/
BLUETOOTH_VIDEO_SINK_UUID = ((unsigned short)0x1304), /**<VEDIO SINK*/
BLUETOOTH_VIDEO_DISTRIBUTION_UUID = ((unsigned short)0x1305), /**<VEDIO DISTRIBUTION*/
BLUETOOTH_HDP_UUID = ((unsigned short)0x1400), /**<HDP*/
gboolean paired; /**< paired flag */
bluetooth_connected_link_t connected; /**< connected link type */
gboolean trust; /**< trust flag */
+ gboolean is_alias_set; /** is device alias set flag**/
bluetooth_manufacturer_data_t manufacturer_data; /**< manafacturer specific class */
} bluetooth_device_info_t;
} bluetooth_le_device_info_t;
typedef struct {
+ bluetooth_device_address_t device_address; /**< device address */
+ int addr_type; /**< address type*/
+ int rssi; /**< received strength signal*/
+ int adv_type;
+ int company_id; /** <Company ID> */
+ int ibeacon_type; /** <iBeacon type> */
+ int major_id; /** <Major ID> */
+ int minor_id; /** <Minor ID> */
+ int measured_power; /** <Measured Power value for proximity> */
+ int uuid_len; /** <uuid string len> */
+ char uuid[BLUETOOTH_UUID_STRING_MAX]; /** <customr/specific UUID> */
+} bluetooth_ibeacon_device_info_t;
+
+typedef struct {
int slot_id;
bluetooth_le_scan_filter_feature_t added_features; /**< added features */
bluetooth_device_address_t device_address; /**< device address */
bluetooth_le_advertising_data_t manufacturer_data_mask; /**< manufacturer data mask */
} bluetooth_le_scan_filter_t;
+typedef struct {
+ bluetooth_device_address_t device_address; /**< device address */
+ unsigned int mtu; /** < MTU set for the ATT connection */
+ unsigned int status; /** < status of the MTU exchange */
+} bluetooth_le_att_mtu_info_t;
+
/**
* structure to hold the paired device information
*/
HTYPE_TRANS_SET_PROTOCOL,
HTYPE_TRANS_DATA,
HTYPE_TRANS_UNKNOWN
-} bluetooth_hid_header_type_t;
+} bt_hid_header_type_t;
/**
* HID Param type
typedef enum {
PTYPE_DATA_RTYPE_INPUT,
PTYPE_DATA_RTYPE_OUTPUT
-} bluetooth_hid_param_type_t;
+} bt_hid_param_type_t;
/**
* Stucture to hid receive data
*/
typedef struct {
const char *address;
- bluetooth_hid_header_type_t type;
+ bt_hid_header_type_t type;
/**< Header type containing */
- bluetooth_hid_param_type_t param;
+ bt_hid_param_type_t param;
/**< Param type in header like INPUT Report or OutPut Report */
int buffer_size;/**< the length of the receive buffer */
char *buffer;
* Stucture to OPP client transfer information
*/
typedef struct {
+ char *device_addr;
char *filename;
unsigned long size;
int percentage;
typedef struct {
char *filename;
int length;
+ char *address;
+ char *name;
} bt_obex_server_authorize_into_t;
/**
unsigned long file_size;
int percentage;
bt_obex_server_type_t server_type;
+ char *address;
+ unsigned char *contact_auth_info;
} bt_obex_server_transfer_info_t;
/**
+ * Stucture to OPP/FTP server connection/disconnection information
+ */
+typedef struct {
+ char *address;
+ char *device_name;
+ int transfer_id;
+} bt_obex_server_connection_info_t;
+
+
+/**
* Stucture to OOB data
*/
unsigned char randomizer[BLUETOOTH_OOB_DATA_LENGTH];
unsigned int hash_len;
unsigned int randomizer_len;
+
+ unsigned char hash256[BLUETOOTH_OOB_DATA_LENGTH];
+ unsigned char randomizer256[BLUETOOTH_OOB_DATA_LENGTH];
+ unsigned int hash256_len;
+ unsigned int randomizer256_len;
} bt_oob_data_t;
/**
guint32 val_len;
} bt_gatt_value_change_t;
+typedef struct {
+ bluetooth_device_address_t device_addr;
+ char *svc_path;
+ bluetooth_gatt_service_change_type_t change_type;
+} bt_gatt_service_change_t;
+
/**
* Structure to GATT characteristc Notification change
*/
char *service_handle;
char *address;
gboolean complete;
- } bt_gatt_indicate_confirm_t;
+} bt_gatt_indicate_confirm_t;
/**
* Structure to RSSI Signal Strength Alert
int high_threshold;
} bt_rssi_threshold_t;
+
+/**
+ * Structure for Suppoted Profiles and Trusted Profiles
+ */
+typedef struct {
+ char *address;
+ int profile;
+ gboolean supported;
+ gboolean trusted;
+} bt_supported_profile_trusted_t;
+
/**
* Structure for PBAP Folder Parameters
*/
} bt_hf_call_list_s;
/**
- * Structure for LE data length change params
+ * Profile types
*/
+typedef enum {
+ TRUSTED_PROFILE_PBAP = 1,
+ TRUSTED_PROFILE_MAP,
+ TRUSTED_PROFILE_SAP,
+ TRUSTED_PROFILE_ALL = 0xFFFFFFFF,
+} bluetooth_trusted_profile_t;
+/**
+ * Restricted Profile types
+ */
+typedef enum {
+ RESTRICTED_PROFILE_HFP_HS = 1,
+ RESTRICTED_PROFILE_A2DP,
+} bluetooth_restricted_profile_t;
+
+/**
+ * Structure for LE data length change params
+ */
typedef struct {
bluetooth_device_address_t device_address;
guint16 max_tx_octets;
guint16 max_rx_time;
} bt_le_data_length_params_t;
+/**
+ * Structure for proximity property change params
+ */
+typedef struct {
+ bluetooth_device_address_t device_address;
+ int role;
+ int service_type;
+ int alert_lvl;
+} bt_pxp_property_changed_params_t;
/**
* @brief DPM BT allowance state
* @see
*/
- typedef enum {
- BLUETOOTH_DPM_ERROR = -1, /**< bluetooth allowance error */
- BLUETOOTH_DPM_BT_ALLOWED, /**< bluetooth allowance allowed */
- BLUETOOTH_DPM_HANDSFREE_ONLY, /**< bluetooth allowance handsfree only */
- BLUETOOTH_DPM_BT_RESTRICTED, /**< bluetooth allowance restricted */
- } bt_dpm_allow_t;
+typedef enum {
+ BLUETOOTH_DPM_ERROR = -1, /**< bluetooth allowance error */
+ BLUETOOTH_DPM_BT_ALLOWED, /**< bluetooth allowance allowed */
+ BLUETOOTH_DPM_HANDSFREE_ONLY, /**< bluetooth allowance handsfree only */
+ BLUETOOTH_DPM_BT_RESTRICTED, /**< bluetooth allowance restricted */
+} bt_dpm_allow_t;
/**
* @brief DPM API result
typedef struct {
bluetooth_device_address_t btaddr;
char if_name[16];
-} bt_ipsp_interface_info_t;
+} bt_ipsp_connection_info_t;
/**
* Callback pointer type
{
GMainLoop *main_loop = NULL;
int ret = 0;
+ g_type_init();
main_loop = g_main_loop_new(NULL, FALSE);
ret = bluetooth_register_callback(bt_event_callback, (void*)main_loop);
if (ret >= BLUETOOTH_ERROR_NONE)
{
GMainLoop *main_loop = NULL;
int ret = 0;
+ g_type_init();
main_loop = g_main_loop_new(NULL, FALSE);
ret = bluetooth_register_callback(bt_event_callback, (void*)main_loop);
if (ret >= BLUETOOTH_ERROR_NONE)
bluetooth_connected_link_t *connected_link);
/**
+ * @fn int bluetooth_set_profile_trusted(const bluetooth_device_address_t *device_address, int profile, int trust)
+ * @brief Sets a profile trusted for a device
+ *
+ * This function is used to Set a profile as trusted for a device
+ *
+ * This function is a synchronous call.
+ *
+ * @param[in] device_address a device address of remote bluetooth device
+ * @param[in] profile profile which is to be set as trusted[0-PBAP, 1-MAP, 2-SAP]
+ * @param[in] trust to set as trusted or untrusted[1-trusted 0-untrusted]
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
+ * BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
+ *
+ * @remark None
+ */
+int bluetooth_set_profile_trusted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int trust);
+
+/**
+ * @fn int bluetooth_get_profile_trusted(const bluetooth_device_address_t *device_address, int profile, int *trust)
+ * @brief Gets a profile is trusted for a device
+ *
+ * This function is used to Get a profile is trusted or not for a device
+ *
+ * This function is a synchronous call.
+ *
+ * @param[in] device_address a device address of remote bluetooth device
+ * @param[in] profile profile whose trust status is needed[0-PBAP, 1-MAP, 2-SAP]
+ * @param[out] trust profile is set as trusted or untrusted[1-trusted 0-untrusted]
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
+ * BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
+ *
+ * @remark None
+ */
+int bluetooth_get_profile_trusted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int *trust);
+
+/**
+ * @fn int bluetooth_set_profile_restricted(const bluetooth_device_address_t *device_address, int profile, int restricted)
+ * @brief Sets a profile restricted connection for a device
+ *
+ * This function is used to Set a profile as restricted for a device
+ *
+ * This function is a synchronous call.
+ *
+ * @param[in] device_address a device address of remote bluetooth device
+ * @param[in] profile profile which is to be set as restricted[1-HFP_HS, 2-A2DP]
+ * @param[in] restricted to set as restricted or not[1-restricted 0-permitted]
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
+ * BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
+ *
+ * @remark None
+ */
+int bluetooth_set_profile_restricted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int restricted);
+
+/**
+ * @fn int bluetooth_get_profile_restricted(const bluetooth_device_address_t *device_address, int profile, int *restricted)
+ * @brief Gets a restricted connection state
+ *
+ * This function is used to Get a profile is restricted or not for a device
+ *
+ * This function is a synchronous call.
+ *
+ * @param[in] device_address a device address of remote bluetooth device
+ * @param[in] profile profile whose restricted status is needed[1-HFP_HS, 2-A2DP]
+ * @param[out] restricted profile is set as restricted or not[1-restricted 0-permitted]
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
+ * BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
+ *
+ * @remark None
+ */
+int bluetooth_get_profile_restricted(
+ const bluetooth_device_address_t *device_address,
+ int profile, int *restricted);
+
+/**
* @fn int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *discoverable_mode_ptr)
* @brief Get the visibility mode
*
*/
gboolean bluetooth_is_le_scanning(void);
+gboolean bluetooth_is_scan_filter_supported(void);
+
+/**
+ * @fn int bluetooth_force_hcidump(int timeout)
+ * @brief Enable /disable force-hcidump
+ *
+ * This function control force-hcidump.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
+ *
+ * @param[in] start To enable or disable force-hcidump[TRUE / FALSE]
+ *
+ *
+ * @remark None
+ */
+int bluetooth_force_hcidump(int timeout);
+
/**
* @fn int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id)
* @brief Register scan filter.
*/
int bluetooth_get_bonded_device_list(GPtrArray **dev_list);
+int bluetooth_get_profile_connected_device_list(
+ const char *profile_uuid, GPtrArray **addr_list);
+
/**
* @fn int bluetooth_get_bonded_device(const bluetooth_device_address_t *device_address,
* bluetooth_device_info_t *dev_info)
bluetooth_device_info_t *dev_info);
/**
+ * @fn int bluetooth_get_is_alias_set(const bluetooth_device_address_t *device_address,
+ * gboolean *is_alias_set)
+ * @brief Get is_alias_set property of device
+ *
+ * This API gets is_alias_set property of a bonded device.
+ *
+ * This function is a synchronous call.
+ * Information for is_alias_set property can be obtained only when result code is BLUETOOTH_ERROR_NONE.
+ * If not,there is no valid information in the is_alias_set.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_NOT_SUPPORT - Opreation not supported \n
+ * @remark None
+ @code
+ int ret = 0;
+ gboolean alias_set;
+ bluetooth_device_address_t device_address = {{0x00,0x1C,0x43,0x2B,0x1A,0xE5}};
+
+ ret = bluetooth_get_is_alias_set(&device_address, &alias_set);
+ @endcode
+ */
+int bluetooth_get_is_alias_set(const bluetooth_device_address_t *device_address,
+ gboolean *is_alias_set);
+
+/**
* @fn int bluetooth_set_alias(const bluetooth_device_address_t *device_address, const char *alias)
* @brief set alias for bonded device
*
*
* @exception None
* @remark None
- * @see bluetooth_rfcomm_reject_connection
+ * @see bluetooth_rfcomm_reject_connection
*/
int bluetooth_rfcomm_accept_connection(int server_fd);
*
* @exception None
* @remark None
- * @see bluetooth_rfcomm_accept_connection
+ * @see bluetooth_rfcomm_accept_connection
*/
int bluetooth_rfcomm_reject_connection(int server_fd);
* should be HDP_QOS_ANY.
* @param[out] app_handle The application handler against corresponding service
* @remark None
- * @see bluetooth_hdp_deactivate
+ * @see bluetooth_hdp_deactivate
*/
int bluetooth_hdp_activate(unsigned short data_type,
bt_hdp_role_type_t role,
* @exception None
* @param[in] app_handle The application handler against corresponding service
* @remark None
- * @see bluetooth_hdp_deactivate
+ * @see bluetooth_hdp_deactivate
*/
int bluetooth_hdp_deactivate(const char *app_handle);
* @param[in] buffer The pdu buffer.
* @param[in] size Size of the buffer.
* @remark None
- * @see bluetooth_hdp_connect
+ * @see bluetooth_hdp_connect
*/
int bluetooth_hdp_send_data(unsigned int channel_id,
const char *buffer, unsigned int size);
* @param[in] device_address The remote device Bd address.
*
* @remark None
- * @see bluetooth_hdp_disconnect
+ * @see bluetooth_hdp_disconnect
*/
int bluetooth_hdp_connect(const char *app_handle,
bt_hdp_qos_type_t channel_type,
* @param[in] device_address The remote device Bd address.
*
* @remark None
- * @see bluetooth_hdp_connect
+ * @see bluetooth_hdp_connect
*/
int bluetooth_hdp_disconnect(unsigned int channel_id,
const bluetooth_device_address_t *device_address);
* @exception None
*
* @remark None
- * @see bluetooth_opc_deinit
+ * @see bluetooth_opc_deinit
*/
int bluetooth_opc_init(void);
* @exception None
*
* @remark None
- * @see bluetooth_opc_init
+ * @see bluetooth_opc_init
*/
- int bluetooth_opc_deinit(void);
+int bluetooth_opc_deinit(void);
/**
* @fn int bluetooth_opc_push_files(bluetooth_device_address_t *remote_address,
* @param[in] file_name_array Array of filepaths to be sent.
*
* @remark None
- * @see bluetooth_opc_cancel_push
+ * @see bluetooth_opc_cancel_push
*/
int bluetooth_opc_push_files(bluetooth_device_address_t *remote_address,
- char **file_name_array);
+ char **file_name_array);
/**
* @fn int bluetooth_opc_cancel_push(void)
* @exception None
*
* @remark None
- * @see bluetooth_opc_push_files
+ * @see bluetooth_opc_push_files
*/
int bluetooth_opc_cancel_push(void);
* @exception None
*
* @remark None
- * @see None
+ * @see None
*/
gboolean bluetooth_opc_session_is_exist(void);
int bluetooth_opc_is_sending(gboolean *is_sending);
/**
+ * @fn int bluetooth_opp_get_transfer_progress(bluetooth_opp_transfer_type_t transfer_type,
+ int transfer_id, unsigned char *progress)
+ * @brief Gets the percentage progress for ongoing transfers.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Not found \n
+ *
+ * @exception None
+ * @param[in] transfer_type Transfer Type: (@c BLUETOOTH_TRANSFER_INBOUND = receiving , @c BLUETOOTH_TRANSFER_OUTBOUND = sending)
+ * @param[in] transfer_id Transfer ID
+ * @param[out] progress Percentage Progress
+ * @remark None
+ * @see None
+ */
+int bluetooth_opp_get_transfer_progress(bluetooth_opp_transfer_type_t transfer_type,
+ int transfer_id, unsigned char *progress);
+
+/**
* @fn int bluetooth_obex_server_init(const char *dst_path)
* @brief Initialize OPP and FTP server.
*
* @exception None
* @param[in] dst_path OPS destination file path.
* @remark None
- * @see bluetooth_obex_server_deinit
+ * @see bluetooth_obex_server_deinit
*/
int bluetooth_obex_server_init(const char *dst_path);
* @exception None
*
* @remark None
- * @see bluetooth_obex_server_init
+ * @see bluetooth_obex_server_init
*/
int bluetooth_obex_server_deinit(void);
* @exception None
* @param[in] dst_path OPS destination file path.
* @remark None
- * @see bluetooth_obex_server_deinit_without_agent
+ * @see bluetooth_obex_server_deinit_without_agent
*/
int bluetooth_obex_server_init_without_agent(const char *dst_path);
* @exception None
*
* @remark None
- * @see bluetooth_obex_server_init_without_agent
+ * @see bluetooth_obex_server_init_without_agent
*/
int bluetooth_obex_server_deinit_without_agent(void);
*
* @exception None
* @remark None
- * @see bluetooth_obex_server_reject_authorize
+ * @see bluetooth_obex_server_reject_authorize
*/
int bluetooth_obex_server_accept_connection(void);
*
* @exception None
* @remark None
- * @see bluetooth_obex_server_reject_authorize
+ * @see bluetooth_obex_server_reject_authorize
*/
int bluetooth_obex_server_reject_connection(void);
* @param[in] filename Authorized filename.
* @remark None
- * @see bluetooth_obex_server_reject_authorize
+ * @see bluetooth_obex_server_reject_authorize
*/
int bluetooth_obex_server_accept_authorize(const char *filename);
* @exception None
* @remark None
- * @see bluetooth_obex_server_accept_authorize
+ * @see bluetooth_obex_server_accept_authorize
*/
int bluetooth_obex_server_reject_authorize(void);
* @param[in] dst_path OPS destination file path.
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_obex_server_set_destination_path(const char *dst_path);
* @param[in] root FTS root folder.
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_obex_server_set_root(const char *root);
* @param[in] transfer_id transfer ID
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_obex_server_cancel_transfer(int transfer_id);
* @exception None
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_obex_server_cancel_all_transfers(void);
* @param[out] is_receiving The receiving status: (@c TRUE = in receiving , @c false = not in receiving)
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_obex_server_is_receiving(gboolean *is_receiving);
* @param[out] local_oob_data - Pointer to the local OOB data
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_oob_read_local_data(bt_oob_data_t *local_oob_data);
* @param[in] remote_device_address - Remote device address
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_oob_remove_remote_data(
*/
int bluetooth_gatt_discover_service_characteristics(const char *service_handle);
+int bluetooth_gatt_set_service_change_watcher(
+ const bluetooth_device_address_t *address, gboolean enable);
+
/**
* @fn int bluetooth_gatt_get_service_property(const char *service_handle,
* bt_gatt_service_property_t *service);
* @param[in] service_handle - Handle for remote service.
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_gatt_watch_characteristics(const char *service_handle);
* @remark None
* @see None
*/
- int bluetooth_gatt_get_service_from_uuid(bluetooth_device_address_t *address,
+int bluetooth_gatt_get_service_from_uuid(bluetooth_device_address_t *address,
const char *service_uuid,
bt_gatt_service_property_t *service);
* @remark None
* @see bluetooth_gatt_get_characteristics_property()
*/
- int bluetooth_gatt_free_char_property(bt_gatt_char_property_t *char_pty);
+int bluetooth_gatt_free_char_property(bt_gatt_char_property_t *char_pty);
/**
* @fn int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty);
* @remark None
* @see bluetooth_gatt_get_char_descriptor_property()
*/
- int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty);
-
+int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty);
- int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect);
+int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect);
- int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address);
+int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address);
/**
* @fn int bluetooth_gatt_discover_characteristic_descriptor(const char *characteristic_handle);
* @remark None
* @see None
*/
- int bluetooth_gatt_read_descriptor_value(const char *desc_handle);
+int bluetooth_gatt_read_descriptor_value(const char *desc_handle);
/**
* @fn int bluetooth_gatt_write_descriptor_value(const char *desc_handle,
* @remark None
* @see None
*/
- int bluetooth_gatt_write_descriptor_value(const char *desc_handle,
+int bluetooth_gatt_write_descriptor_value(const char *desc_handle,
const guint8 *value, int length);
/* @fn int bluetooth_gatt_init(void)
*
* This function is a synchronous call.
* @return BLUETOOTH_ERROR_NONE - Success \n
-* BLUETOOTH_ERROR_INTERNAL - Internal Error \n
-* BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
-* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+* BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+* BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
+* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
*
* @exception None
* @remark Adapter should be enabled
*
* This function is a synchronous call.
* @return BLUETOOTH_ERROR_NONE - Success \n
-* BLUETOOTH_ERROR_INTERNAL - Internal Error \n
-* BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
-* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
+* BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+* BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
+* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
*
* @exception None
* @remark Adapter should be enabled
* BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
* BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
*
-* @exception None
-* @param[in] desc_uuid Gatt descriptor uuid.
-* @param[in] desc_value GATT descriptor value.
-* @param[in] value_length Length of GATT descriptor value.
-* @param[in] permissions descriptor permissions.
-* @param[in] properties GATT descriptor properties.
-* @param[in] char_path characteristics object path of the exported character.
+* @exception None
+* @param[in] desc_uuid Gatt descriptor uuid.
+* @param[in] desc_value GATT descriptor value.
+* @param[in] value_length Length of GATT descriptor value.
+* @param[in] permissions descriptor permissions.
+* @param[in] properties GATT descriptor properties.
+* @param[in] char_path characteristics object path of the exported character.
*
* @remark Adapter should be enabled
* @see bluetooth_gatt_add_service()
*
* @exception None
* @param[in] desc_value GATT descriptor value.
-* @param[in] value_length Length of GATT descriptor value.
-* @param[in] desc_path descriptor path to which the value needs to be added.
+* @param[in] value_length Length of GATT descriptor value.
+* @param[in] desc_path descriptor path to which the value needs to be added.
*
* @remark Adapter should be enabled
* @see bluetooth_gatt_add_service()
/* @fn int bluetooth_gatt_register_service(const char *svc_path)
*
-* @brief Registers the given service path with the bluez gatt server.
+* @brief Registers the given service path with the library.
*
* This function is a synchronous call.
*
* @see bluetooth_bond_device
*/
int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
- const bluetooth_le_connection_param_t *parameters);
-
+ const bluetooth_le_connection_param_t *parameters);
/**
* @fn int bluetooth_enable_le_privacy(gboolean enable_privacy);
int bluetooth_enable_le_privacy(gboolean enable_privacy);
/**
+ * @fn int bluetooth_set_le_static_random_address(gboolean enable);
+ *
+ * @brief Enable/Disable LE static random address.
+ *
+ * This function is used to enable or disable LE static random address.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
+ *
+ * @exception None
+ * @param[in] enable - The status of LE static random address to be activated/deactivated[True/False].
+ *
+ * @remark None
+ */
+int bluetooth_set_le_static_random_address(gboolean enable);
+
+/**
* @fn int bluetooth_update_le_connection_mode(bluetooth_device_address_t *address,
* bluetooth_le_connection_mode_t mode)
* @brief update connection paramter of LE connection.
bluetooth_le_connection_mode_t mode);
/**
+ * @fn int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, guint16 mtu)
+ * @brief Request for new ATT MTU value.
+ *
+ * This function is a asynchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] address - remote device address value.
+ * @param[in] mtu - MTU value to be set.
+ *
+ * @remark None
+ */
+int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu);
+
+/**
+ * @fn int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
+ * unsigned int *mtu)
+ * @brief Gets the xisting MTU value set for a connection.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] address - remote device address value.
+ * @param[out] mtu - MTU value set for the connection.
+ *
+ * @remark None
+ */
+int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
+ unsigned int *mtu);
+
+/**
+ * @fn int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
+ * bluetooth_device_address_t *id_address)
+ * @brief Gets the Identity address of remote device.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_INTERNAL - Internal Error \n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
+ *
+ * @exception None
+ * @param[in] device_rpa - remote Resolvable private address.
+ * @param[out] id_address - remote Identity device address value.
+ *
+ * @remark None
+ */
+int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
+ bluetooth_device_address_t *id_address);
+
+/**
* @fn int bluetooth_le_read_maximum_data_length()
* @brief reads the maximum LE data length supported in the controller.
*
*/
int bluetooth_set_manufacturer_data(const bluetooth_manufacturer_data_t *value);
+int bluetooth_set_passkey_notification(gboolean enable);
+
#ifdef TIZEN_DPM_VCONF_ENABLE
/**
* @fn int bluetooth_dpm_is_mode_allowed(void);
* @exception None
* @param[in] None
* @param[out] value - BT Allow value.
- * BLUETOOTH_DPM_ERROR = -1, < bluetooth allowance error
- * BLUETOOTH_DPM_BT_ALLOWED, < bluetooth allowance allowed
- * BLUETOOTH_DPM_HANDSFREE_ONLY, < bluetooth allowance handsfree only
- * BLUETOOTH_DPM_BT_RESTRICTED, < bluetooth allowance restricted
+ * BLUETOOTH_DPM_ERROR = -1, < bluetooth allowance error
+ * BLUETOOTH_DPM_BT_ALLOWED, < bluetooth allowance allowed
+ * BLUETOOTH_DPM_HANDSFREE_ONLY, < bluetooth allowance handsfree only
+ * BLUETOOTH_DPM_BT_RESTRICTED, < bluetooth allowance restricted
*
* @remark None
*/
*
* @exception None
* @param[in] value - State value.
- * BLUETOOTH_DPM_ALLOWED = 0, < DPM Policy status allowed.
+ * BLUETOOTH_DPM_ALLOWED = 0, < DPM Policy status allowed.
* BLUETOOTH_DPM_RESTRICTED = 1, < DPM Policy status restricted.
*
* @remark None
int bluetooth_dpm_get_data_transfer_state(bt_dpm_status_t *value);
/**
+ * @fn int bluetooth_set_proximity_property(const bluetooth_device_address_t *device_address,
+ * bluetooth_pxp_poperty_t property, int value);
+ *
+ * @brief Sets the Proximity alert level/properties.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ *
+ * @exception None
+ * @param[in] device_address remote device address
+ * @param[in] property proximity profile property
+ * @param[in] value alert level/property value to be set
+ * @param[out] None
+ *
+ * @remark None
+ */
+int bluetooth_set_proximity_property(const bluetooth_device_address_t *device_address,
+ bluetooth_pxp_poperty_t property, int value);
+
+/**
+ * @fn int bluetooth_get_proximity_property(const bluetooth_device_address_t *device_address,
+ * bluetooth_pxp_poperty_t property, int *value);
+ *
+ * @brief Reads the Proximity alert level/properties.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ *
+ * @exception None
+ * @param[in] device_address remote device address
+ * @param[in] property proximity profile property
+ * @param[out] value alert level/property value
+ *
+ * @remark None
+ */
+int bluetooth_get_proximity_property(const bluetooth_device_address_t *device_address,
+ bluetooth_pxp_poperty_t property, int *value);
+
+/**
+ * @fn int bluetooth_get_proximity_supported_services(const bluetooth_device_address_t *device_address,
+ * int *services_supported);
+ *
+ * @brief Reads the Proximity profile supported properties/services.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
+ * BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
+ *
+ * @exception None
+ * @param[in] device_address remote device address
+ * @param[out] services_supported proximity profile property/service
+ *
+ * @remark None
+ */
+int bluetooth_get_proximity_supported_services(const bluetooth_device_address_t *device_address,
+ int *services_supported);
+
+/**
+ * @fn int bluetooth_register__proximity_reporter();
+ *
+ * @brief Register all proximity related services in BlueZ.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+int bluetooth_register_proximity_reporter();
+
+/**
+ * @fn int bluetooth_unregister__proximity_reporter();
+ *
+ * @brief Unregister all proximity related services in BlueZ.
+ *
+ * This function is a synchronous call.
+ *
+ * @return BLUETOOTH_ERROR_NONE - Success \n
+ * BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
+ *
+ * @exception None
+ *
+ * @remark None
+ */
+int bluetooth_unregister_proximity_reporter();
+
+/**
* @}
*/
BLUETOOTH_AV_STATE_DISCONNECTED,
} bt_av_conn_status_t;
+typedef enum {
+ BLUETOOTH_HF_CIEV_BATTCHG, /* BT_HF_REMOTE_DEVICE_STATE_BATTERY_LEVEL */
+ BLUETOOTH_HF_CIEV_SIGNAL, /* BT_HF_REMOTE_DEVICE_STATE_SIGNAL_STRENGTH */
+ BLUETOOTH_HF_CIEV_SERVICE, /* BT_HF_REMOTE_DEVICE_STATE_NETWORK_SERVICE */
+ BLUETOOTH_HF_VR_STATUS, /* BT_HF_REMOTE_DEVICE_STATE_VOICE_RECOGNITON */
+} bt_hf_ciev_device_state_t;
+
typedef void (*bt_audio_func_ptr) (int, bt_audio_event_param_t *, void *);
typedef struct {
} bt_audio_info_t;
typedef enum {
- BLUETOOTH_STATE_NONE = 0x0000,
- BLUETOOTH_STATE_HEADSET_CONNECTED = 0x0004,
- BLUETOOTH_STATE_A2DP_HEADSET_CONNECTED = 0x0010,
+ BLUETOOTH_STATE_NONE = 0x0000,
+ BLUETOOTH_STATE_HEADSET_CONNECTED = 0x0004,
+ BLUETOOTH_STATE_A2DP_HEADSET_CONNECTED = 0x0010,
} bluetooth_device_state_t;
/**
* @brief The function bluetooth_audio_init called to initializes the Audio
- * service to bluetoothD and Global data related to audio.
+ * service to bluetoothD and Global data related to audio.
* @param[in] cb Callback function
* @param[in] user_data Data sent by application, which will be
* returned in event handler.
int bluetooth_hf_is_connected(gboolean *hf_connected);
+int bluetooth_hf_is_ibr_supported(gboolean*ibr_supported);
+
#ifdef __cplusplus
}
#endif /*__cplusplus*/
*/
int bluetooth_hid_disconnect(hid_device_address_t *device_address);
+int bluetooth_hid_enable_barcode_feature(void);
+
/**
* @fn int bluetooth_hid_device_init(hid_cb_func_ptr callback_ptr, void *user_data)
* @brief Initialize HID Device service and register the callback
hid_send_key_event_t send_event);
/**
+ * @fn int bluetooth_hid_device_send_custom_event(const char *remote_addr,
+ * unsigned char btcode, unsigned char report_id,
+ * const char *data, unsigned int data_len)
+ *
+ * @brief write the event data on the socket.
+ *
+ * This function is a asynchronous call.
+ *
+ * @return HID_ERROR_NONE - Success \n
+ * HID_ERROR_INVALID_PARAM - Invalid parameter \n
+ * HID_ERROR_NOT_INITIALIZED - Internal Error \n
+ * HID_ERROR_NOT_ENABLED - Not enabled \n
+ * HID_ERROR_INTERNAL - Not enabled \n
+ *
+ * @exception None
+ * @param[in] remote_addr device address of remote device.
+ * @param[in] btcode The btcode
+ * @param[in] report_id The report id
+ * @param[in] data This indicates the event data to send to remote device.
+ * @param[in] data_len The length of the data
+ * @remark None
+ */
+int bluetooth_hid_device_send_custom_event(const char *remote_addr,
+ unsigned char btcode, unsigned char report_id,
+ const char *data, unsigned int data_len);
+
+/**
* @fn int bluetooth_hid_device_reply_to_report(const char *remote_addr,
- * bluetooth_hid_header_type_t htype,
- * bluetooth_hid_param_type_t ptype,
+ * bt_hid_header_type_t htype,
+ * bt_hid_param_type_t ptype,
* char *buffer)
*
* @brief write the event data on the socket.
* @remark None
*/
int bluetooth_hid_device_reply_to_report(const char *remote_addr,
- bluetooth_hid_header_type_t htype,
- bluetooth_hid_param_type_t ptype,
+ bt_hid_header_type_t htype,
+ bt_hid_param_type_t ptype,
const char *data,
unsigned int data_len);
} ipsp_device_address_t;
/**
- * @fn int bluetooth_le_ipsp_init(void)
+ * @fn int bluetooth_ipsp_init(void)
*
* @brief Initializes IPSP service and register the service to Bluez
*
* @remark None
*
*/
-int bluetooth_le_ipsp_init(void);
+int bluetooth_ipsp_init(void);
/**
- * @fn int bluetooth_le_ipsp_deinit(void)
+ * @fn int bluetooth_ipsp_deinit(void)
*
* @brief De-Initialize IPSP service and un-register the callback
* The IPSP De-Initialize request is responded by BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED event.
* @remark None
*
*/
-int bluetooth_le_ipsp_deinit(void);
+int bluetooth_ipsp_deinit(void);
/**
- * @fn int bluetooth_le_ipsp_connect(const ipsp_device_address_t *device_address);
+ * @fn int bluetooth_ipsp_connect(const ipsp_device_address_t *device_address);
*
* @brief Connects to IPSP Router device. It establishes connection for 6Lowpan over LE.
*
* @param[in] device_address - remote device address.
*
* @remark None
- * @see bluetooth_le_ipsp_disconnect()
+ * @see bluetooth_ipsp_disconnect()
*/
-int bluetooth_le_ipsp_connect(const ipsp_device_address_t *device_address);
+int bluetooth_ipsp_connect(const ipsp_device_address_t *device_address);
/**
- * @fn int bluetooth_le_ipsp_disconnect(const ipsp_device_address_t *device_address);
+ * @fn int bluetooth_ipsp_disconnect(const ipsp_device_address_t *device_address);
*
* @brief Disconnects to IPSP Router device. It disconnects connection for 6Lowpan over LE.
*
* @param[in] device_address - remote device address.
*
* @remark None
- * @see bluetooth_le_ipsp_disconnect()
+ * @see bluetooth_ipsp_disconnect()
*/
-int bluetooth_le_ipsp_disconnect(const ipsp_device_address_t *device_address);
+int bluetooth_ipsp_disconnect(const ipsp_device_address_t *device_address);
#ifdef __cplusplus
STOP,
NEXT,
PREVIOUS,
- FAST_FORWARD,
- REWIND
+ PRESS_FAST_FORWARD,
+ RELEASE_FAST_FORWARD,
+ PRESS_REWIND,
+ RELEASE_REWIND
} media_player_control_cmd;
typedef struct {
* @param[in] setting - The music player properties
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_media_player_set_properties(
media_player_settings_t *setting);
* value - Value of the property which is changed
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_media_player_change_property(
media_player_property_type type,
* BT_MEDIA_CONTROL_ERROR - Error \n
*
* @exception None
- * @param[in] metadata -Meida attributes
+ * @param[in] metadata -Meida attributes
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_media_player_change_track(
media_metadata_attributes_t *metadata);
* @remark None
*
*/
- int bluetooth_media_control_deinit(void);
+int bluetooth_media_control_deinit(void);
/**
* @brief The function bluetooth_media_control_connect is called to establish an AVRCP
int bluetooth_media_control_disconnect(bluetooth_device_address_t *remote_address);
/**
+ * @brief The function bluetooth_media_target_connect is called to establish an AVRCP
+ * target role connection with the specified device.
+ *
+ * @param[in] remote_address Bluetooth device address.
+ * @return int Zero on Success or reason for error if any.
+ *
+ */
+int bluetooth_media_target_connect(bluetooth_device_address_t *remote_address);
+
+/**
+ * @brief The function bluetooth_media_target_disconnect is called to disconnect an
+ * existing AVRCP target role connection with the specified device.
+ *
+ * @param[in] remote_address Bluetooth device address.
+ * @return int Zero on Success or reason for error if any.
+ *
+ */
+int bluetooth_media_target_disconnect(bluetooth_device_address_t *remote_address);
+
+/**
* @brief The function bluetooth_media_control_command is called to send
* the AVRCP Control command like Play, Pause, FF, Rewind to the target device.
*
- * @param[in] type media_player_control_cmd.
+ * @param[in] type media_player_control_cmd.
* @return int Zero on Success or reason for error if any.
*
*/
* @param[in] setting - The music control properties
*
* @remark None
- * @see None
+ * @see None
*/
- int bluetooth_media_control_set_property(media_player_property_type type, unsigned int value);
+int bluetooth_media_control_set_property(media_player_property_type type, unsigned int value);
/**
* @fn int bluetooth_media_control_get_property(media_player_property_type type, unsigned int *value)
* @param[in] setting - The music control properties
*
* @remark None
- * @see None
+ * @see None
*/
int bluetooth_media_control_get_property(media_player_property_type type, unsigned int *value);
* @param[in] metadata - The music meta data information.
*
* @remark None
- * @see None
+ * @see None
*/
- int bluetooth_media_control_get_track_info(media_metadata_attributes_t *metadata);
+int bluetooth_media_control_get_track_info(media_metadata_attributes_t *metadata);
#ifdef __cplusplus
}
BLUETOOTH_CALL_STATE_ERROR,
} bt_telephony_call_state_t;
+typedef enum {
+ BLUETOOTH_AGENT_ERROR_NONE,
+ BLUETOOTH_AGENT_ERROR_INTERNAL,
+ BLUETOOTH_AGENT_ERROR_NOT_AVAILABLE,
+ BLUETOOTH_AGENT_ERROR_NOT_CONNECTED,
+ BLUETOOTH_AGENT_ERROR_BUSY,
+ BLUETOOTH_AGENT_ERROR_INVALID_PARAM,
+ BLUETOOTH_AGENT_ERROR_ALREADY_EXSIST,
+ BLUETOOTH_AGENT_ERROR_ALREADY_CONNECTED,
+ BLUETOOTH_AGENT_ERROR_NO_MEMORY,
+ BLUETOOTH_AGENT_ERROR_I_O_ERROR,
+ BLUETOOTH_AGENT_ERROR_OPERATION_NOT_AVAILABLE,
+ BLUETOOTH_AGENT_ERROR_NO_CALL_LOGS,
+ BLUETOOTH_AGENT_ERROR_INVALID_MEMORY_INDEX,
+ BLUETOOTH_AGENT_ERROR_INVALID_CHLD_INDEX,
+ BLUETOOTH_AGENT_ERROR_BATTERY_STATUS,
+ BLUETOOTH_AGENT_ERROR_SIGNAL_STATUS,
+ BLUETOOTH_AGENT_ERROR_NOT_SUPPORTED,
+ BLUETOOTH_AGENT_ERROR_INVALID_NUMBER,
+ BLUETOOTH_AGENT_ERROR_APPLICATION,
+ BLUETOOTH_AGENT_ERROR_INVALID_DTMF,
+} bluetooth_telephony_agent_error_t;
+
typedef struct {
unsigned int call_id;
bt_telephony_call_state_t call_status;
* @return int Zero on Success or reason for error if any.
*
*/
- int bluetooth_telephony_is_nrec_enabled(gboolean *status);
+int bluetooth_telephony_is_nrec_enabled(gboolean *status);
/**
* @brief The function bluetooth_telephony_is_nrec_enabled to check
* @return int Zero on Success or reason for error if any.
*
*/
- int bluetooth_telephony_is_wbs_mode(gboolean *status);
+int bluetooth_telephony_is_wbs_mode(gboolean *status);
/**
* @brief This function send XSAT vendor specific AT command
*
* @return int Zero on Success or reason for error if any.
*/
- int bluetooth_telephony_send_vendor_cmd(const char *cmd);
+int bluetooth_telephony_send_vendor_cmd(const char *cmd);
/**
*
* @return int Zero on Success or reason for error if any.
*/
- int bluetooth_telephony_start_voice_recognition(void);
+int bluetooth_telephony_start_voice_recognition(void);
/**
* @brief This function sends request to disable voice recognition feature
*
* @return int Zero on Success or reason for error if any.
*/
- int bluetooth_telephony_stop_voice_recognition(void);
+int bluetooth_telephony_stop_voice_recognition(void);
/**
#define BT_FUNC_GATT_BASE ((int)(BT_FUNC_HDP_BASE + 0x0020))
#define BT_FUNC_IPSP_BASE ((int)(BT_FUNC_GATT_BASE + 0x0020))
#define BT_FUNC_DPM_BASE ((int)(BT_FUNC_IPSP_BASE + 0x0020))
+#define BT_FUNC_PXP_BASE ((int)(BT_FUNC_DPM_BASE + 0x0030)) /* Adding 0x0030 to base, as DPM has more use case */
typedef enum {
BT_CHECK_ADAPTER = BT_FUNC_BASE,
BT_REGISTER_SCAN_FILTER,
BT_UNREGISTER_SCAN_FILTER,
BT_UNREGISTER_ALL_SCAN_FILTERS,
+ BT_IS_SCAN_FILTER_SUPPORTED,
+ BT_GET_PROFILE_CONNECTED_DEVICES,
+ BT_ENABLE_FORCE_HCI_DUMP,
+ BT_SET_PASSKEY_NOTIFICATION,
BT_BOND_DEVICE = BT_FUNC_DEVICE_BASE,
BT_BOND_DEVICE_BY_TYPE,
BT_CANCEL_BONDING,
BT_SEARCH_SERVICE,
BT_CANCEL_SEARCH_SERVICE,
BT_GET_BONDED_DEVICE,
+ BT_GET_IS_ALIAS_SET,
BT_SET_ALIAS,
BT_SET_AUTHORIZATION,
BT_UNSET_AUTHORIZATION,
BT_SET_PIN_CODE,
BT_UNSET_PIN_CODE,
BT_UPDATE_LE_CONNECTION_MODE,
+ BT_SET_PROFILE_TRUSTED,
+ BT_GET_PROFILE_TRUSTED,
+ BT_SET_PROFILE_RESTRICTED,
+ BT_GET_PROFILE_RESTRICTED,
BT_HID_CONNECT = BT_FUNC_HID_BASE,
BT_HID_DISCONNECT,
BT_HID_DEVICE_ACTIVATE,
BT_HID_DEVICE_DISCONNECT,
BT_HID_DEVICE_SEND_MOUSE_EVENT,
BT_HID_DEVICE_SEND_KEY_EVENT,
+ BT_HID_DEVICE_SEND_CUSTOM_EVENT,
BT_HID_DEVICE_SEND_REPLY_TO_REPORT,
+ BT_HID_ENABLE_BARCODE_FEATURE,
BT_NETWORK_ACTIVATE = BT_FUNC_NETWORK_BASE,
BT_NETWORK_DEACTIVATE,
BT_NETWORK_CONNECT,
BT_AVRCP_SET_PROPERTIES,
BT_AVRCP_CONTROL_CONNECT,
BT_AVRCP_CONTROL_DISCONNECT,
+ BT_AVRCP_TARGET_CONNECT,
+ BT_AVRCP_TARGET_DISCONNECT,
BT_AVRCP_HANDLE_CONTROL,
BT_AVRCP_CONTROL_SET_PROPERTY,
BT_AVRCP_CONTROL_GET_PROPERTY,
BT_OPP_PUSH_FILES = BT_FUNC_OPP_BASE,
BT_OPP_CANCEL_PUSH,
BT_OPP_IS_PUSHING_FILES,
+ BT_OPP_GET_TRANSFER_PROGRESS,
BT_OBEX_SERVER_ALLOCATE,
BT_OBEX_SERVER_DEALLOCATE,
BT_OBEX_SERVER_IS_ACTIVATED,
BT_CONNECT_LE,
BT_DISCONNECT_LE,
BT_SET_LE_PRIVACY,
-
+ BT_REQ_ATT_MTU,
+ BT_GET_ATT_MTU,
+ BT_GET_DEVICE_IDA,
+ BT_SET_LE_STATIC_RANDOM_ADDRESS,
BT_HDP_CONNECT = BT_FUNC_HDP_BASE,
BT_HDP_DISCONNECT,
BT_HDP_SEND_DATA,
BT_DPM_GET_LIMITED_DISCOVERABLE_STATE,
BT_DPM_SET_DATA_TRANSFER_STATE,
BT_DPM_GET_DATA_TRANSFER_STATE,
+ BT_PXP_SET_PROPERTY = BT_FUNC_PXP_BASE,
+ BT_PXP_GET_PROPERTY,
+ BT_PXP_GET_SUPPORTED_SERIVCES,
+ BT_PXP_REGISTER_REPORTER,
+ BT_PXP_UNREGISTER_REPORTER,
} bt_function_t;
typedef struct {
#define BT_DPM_SYSPOPUP "dpm-syspopup"
#endif
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_PROFILE_WEARABLE
#define BT_FILE_VISIBLE_TIME "file/private/libug-setting-bluetooth-efl/visibility_time"
#endif
#define BT_OFF_DUE_TO_FLIGHT_MODE "file/private/bt-core/flight_mode_deactivated"
#define BT_OFF_DUE_TO_POWER_SAVING_MODE "file/private/bt-core/powersaving_mode_deactivated"
#define BT_OFF_DUE_TO_TIMEOUT "file/private/bt-service/bt_off_due_to_timeout"
+#define BT_LAST_CONNECTED_DEVICE "file/private/bt-service/last_connected_device"
#define BT_EVENT_SERVICE "org.projectx.bt_event"
#define BT_HF_AGENT_SERVICE "org.bluez.HandsfreeAgent"
#define BT_ADVERTISING_MANUFACTURER_DATA_CHANGED "AdvertisingManufacturerDataChanged"
#define BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED "ScanResponseManufacturerDataChanged"
#define BT_MANUFACTURER_DATA_CHANGED "ManufacturerDataChanged"
+#define BT_PASSKEY_NOTIFICATION "PasskeyNotification"
#define BT_DEVICE_CONNECTED "DeviceConnected"
#define BT_DEVICE_DISCONNECTED "DeviceDisconnected"
#define BT_DEVICE_PROFILE_STATE_CHANGED "ProfileStateChanged"
#define BT_RSSI_MONITORING_ENABLED "RssiMonitoringEnabled"
#define BT_RSSI_ALERT "RssiMonitoringAlert"
#define BT_RAW_RSSI_EVENT "RawRssiEvent"
+#define BT_SUPPORTED_PROFILE_TRUSTED "SupportedProfileTrusted"
#define BT_SERVICE_SEARCHED "ServiceSearched"
#define BT_INPUT_CONNECTED "InputConnected"
#define BT_INPUT_DISCONNECTED "InputDisconnected"
+#define BT_INPUT_HID_DEVICE_CONNECTED "HidDeviceConnected"
+#define BT_INPUT_HID_DEVICE_DISCONNECTED "HidDeviceDisconnected"
#define BT_PBAP_CONNECTED "PbapConnected"
#define BT_PBAP_DISCONNECTED "PbapDisconnected"
#define BT_PBAP_PHONEBOOK_SIZE "PbapPhonebookSize"
#define BT_NAME_OWNER_CHANGED "NameOwnerChanged"
#define BT_GATT_CONNECTED "GattConnected"
#define BT_GATT_DISCONNECTED "GattDisconnected"
+#define BT_GATT_REQ_ATT_MTU_CHANGED "GattReqAttMtuChanged"
#define BT_GATT_CHAR_VAL_CHANGED "GattCharValueChanged"
#ifdef GATT_NO_RELAY
#define BT_GATT_BLUEZ_CHAR_VAL_CHANGED "GattValueChanged"
#define BT_IPSP_INITIALIZED "IpspInitStateChanged"
#define BT_IPSP_CONNECTED "IpspConnected"
#define BT_IPSP_DISCONNECTED "IpspDisconnected"
-#define BT_IPSP_BT_INTERFACE_INFO "IpspBtInterfaceInfo"
#define BT_LE_DATA_LENGTH_CHANGED "LEDataLengthChanged"
#define BT_HDP_CONNECTED "HDPConnected"
#define BT_HDP_DISCONNECTED "HDPDisconnected"
+#define BT_IBEACON_DEVICE_FOUND "iBeaconDeviceFound"
+#define BT_PXP_PROPERTY_CHANGED "PxpValueChanged"
#ifdef __cplusplus
}
Group=users
Type=dbus
BusName=org.projectx.bt
+SmackProcessLabel=User
ExecStart=/usr/bin/bt-service
Restart=always
RestartSec=1
[Service]
User=owner
Group=users
-SupplementaryGroups=priv_mediastorage
+SupplementaryGroups=priv_mediastorage priv_externalstorage
Type=dbus
BusName=org.projectx.bt
SmackProcessLabel=User
Group=users
Type=dbus
BusName=org.projectx.bt
+SmackProcessLabel=User
ExecStart=/usr/bin/bt-service
KillMode=process
Environment=DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/5001/dbus/user_bus_socket
[Unit]
Description=Bluetooth service
-After=multi-user.target
+After=bluetooth.service
[Service]
User=owner
Group=users
+SupplementaryGroups=priv_mediastorage priv_externalstorage
Type=dbus
BusName=org.projectx.bt
+SmackProcessLabel=User
ExecStart=/usr/bin/bt-service
KillMode=process
Environment=DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/5001/dbus/user_bus_socket
[Install]
-WantedBy=starter.target
+WantedBy=multi-user.target
\ No newline at end of file
Group=users
Type=dbus
BusName=org.projectx.bt
+SmackProcessLabel=User
ExecStart=/usr/bin/bt-service
KillMode=process
Environment=DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/5001/dbus/user_bus_socket
Name: bluetooth-frwk
Summary: Bluetooth framework for BlueZ and Obexd.
-Version: 0.2.151
+Version: 0.2.152
Release: 1
Group: Network & Connectivity/Bluetooth
License: Apache-2.0
Source0: %{name}-%{version}.tar.gz
Source1001: bluetooth-frwk.manifest
-%if %{with bluetooth_frwk_libnotify} || %{with bluetooth_frwk_libnotification}
-Source1002: bt-icon.png
-%endif
Requires: dbus
Requires: syspopup
BuildRequires: pkgconfig(glib-2.0)
BuildRequires: pkgconfig(gio-2.0)
BuildRequires: pkgconfig(gio-unix-2.0)
-%if %{with bluetooth_frwk_libnotify}
-BuildRequires: pkgconfig(libnotify)
-BuildRequires: pkgconfig(gdk-pixbuf-2.0)
-BuildRequires: pkgconfig(gtk+-3.0)
-%elif %{without bluetooth_frwk_libnotification}
-BuildRequires: pkgconfig(syspopup-caller)
-Requires: syspopup
-%else
BuildRequires: pkgconfig(syspopup-caller)
-%endif
BuildRequires: pkgconfig(vconf)
BuildRequires: pkgconfig(libxml-2.0)
BuildRequires: pkgconfig(dbus-1)
-%if %{with x}
-BuildRequires: pkgconfig(utilX)
-%endif
BuildRequires: pkgconfig(capi-network-connection)
BuildRequires: pkgconfig(alarm-service)
BuildRequires: pkgconfig(capi-content-mime-type)
%define _servicedir starter.target.wants
%if "%{?profile}" == "mobile"
-export CFLAGS="$CFLAGS -DTIZEN_NETWORK_TETHERING_ENABLE -DTIZEN_BT_FLIGHTMODE_ENABLED -DTIZEN_MOBILE -DTIZEN_TELEPHONY_ENABLED"
+export CFLAGS="$CFLAGS -DTIZEN_FEATURE_NETWORK_TETHERING_ENABLE -DTIZEN_FEATURE_FLIGHTMODE_ENABLED -DTIZEN_PROFILE_MOBILE -DTIZEN_FEATURE_TELEPHONY_ENABLED"
%if "%{?tizen_target_name}" == "TM1"
%define _servicefile packaging/bluetooth-frwk-mobile-sprd.service
%else
%endif
%if "%{?profile}" == "wearable"
-export CFLAGS="$CFLAGS -DTIZEN_WEARABLE -DTIZEN_BT_FLIGHTMODE_ENABLED"
+export CFLAGS="$CFLAGS -DTIZEN_PROFILE_WEARABLE -DTIZEN_FEATURE_FLIGHTMODE_ENABLED"
%define _servicefile packaging/bluetooth-frwk-wearable.service
%define _servicedir multi-user.target.wants
%endif
%if "%{?profile}" == "tv"
export CFLAGS="$CFLAGS -DUSB_BLUETOOTH -DTIZEN_TV -DAUTO_ACCEPT"
-%define _servicefile packaging/bluetooth-frwk-mobile.service
+%define _servicefile packaging/bluetooth-frwk-tv.service
+%define _servicedir multi-user.target.wants
+%endif
+
+%if "%{?profile}" == "ivi"
+export CFLAGS="$CFLAGS -DTIZEN_PROFILE_IVI"
+%define _servicefile packaging/bluetooth-frwk-wearable.service
%define _servicedir multi-user.target.wants
%endif
export LDFLAGS="$CFLAGS -Wl,--rpath=%{_libdir} -Wl,--as-needed -Wl,--unresolved-symbols=ignore-in-shared-libs"
%if "%{?_with_emulator}" == "1"
-export CFLAGS="$CFLAGS -DEMUL"
-export CXXFLAGS="$CXXFLAGS -DEMUL"
-export FFLAGS="$FFLAGS -DEMUL"
+export CFLAGS="$CFLAGS -DTIZEN_TEST_EMUL"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_TEST_EMUL"
+export FFLAGS="$FFLAGS -DTIZEN_TEST_EMUL"
+%endif
+
+%if "%{?tizen_target_name}" == "TM1"
+export CFLAGS="${CFLAGS} -DTIZEN_FEATURE_RADIO"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_FEATURE_RADIO"
+export FFLAGS="$FFLAGS -DTIZEN_FEATURE_RADIO"
%endif
%if %{bt_hal} == ENABLED
-DCMAKE_LIB_DIR=%{_libdir} \
-DTZ_SYS_USER_GROUP=%TZ_SYS_USER_GROUP \
-DTZ_SYS_DEFAULT_USER=%TZ_SYS_DEFAULT_USER \
-%if %{with bluetooth_frwk_libnotify}
- -DLIBNOTIFY_SUPPORT=On \
-%else
-DLIBNOTIFY_SUPPORT=Off \
-%endif
-%if %{with bluetooth_frwk_libnotification}
- -DLIBNOTIFICATION_SUPPORT=On
-%else
-DLIBNOTIFICATION_SUPPORT=Off
-%endif
-
make
%cmake \
%if "%{?profile}" == "wearable"
- -DTIZEN_WEARABLE=YES \
+ -DTIZEN_PROFILE_WEARABLE=YES \
%else
- -DTIZEN_WEARABLE=NO \
+ -DTIZEN_PROFILE_WEARABLE=NO \
%endif
%if "%{?profile}" == "common"
- -DTIZEN_WEARABLE=NO \
+ -DTIZEN_PROFILE_WEARABLE=NO \
%endif
%install
install -m 0644 %{_servicefile} %{buildroot}%{_unitdir}/bluetooth-frwk.service
ln -s ../bluetooth-frwk.service %{buildroot}%{_unitdir}/%{_servicedir}/bluetooth-frwk.service
-%if %{with bluetooth_frwk_libnotify} || %{with bluetooth_frwk_libnotification}
-mkdir -p %{buildroot}%{_datadir}/icons/default
-install -m 0644 %{SOURCE1002} %{buildroot}%{_datadir}/icons/default/bt-icon.png
-%endif
-
# On IVI bt-service needs to be run as 'app' even if there is a 'guest' user.
%if "%{profile}"=="ivi"
sed -i 's/%TZ_SYS_DEFAULT_USER/app/' %{buildroot}%{_datadir}/dbus-1/system-services/org.projectx.bt.service
#%attr(0666,-,-) %{_varlibdir}/bluetooth/auto-pair-blacklist
#%attr(0666,-,-) %{_prefix}/etc/bluetooth/stack_info
#%{_dumpdir}/bluetooth_log_dump.sh
-
-
%{_datadir}/license/bluetooth-frwk-service
-%if %{with bluetooth_frwk_libnotify} || %{with bluetooth_frwk_libnotification}
-%{_datadir}/icons/default/bt-icon.png
-%endif
%files httpproxy
%manifest %{name}.manifest
INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
-#ADD_SUBDIRECTORY(media-control)
-#ADD_SUBDIRECTORY(telephony)
ADD_SUBDIRECTORY(gatt-test)
-#ADD_SUBDIRECTORY(handsfree)
ADD_SUBDIRECTORY(le-adv)
int i = 0;
while (tc_table[i].tc_name) {
- if (tc_table[i].tc_code != 0x00ff) {
+ if (tc_table[i].tc_code != 0x00ff)
TC_PRT("Key %d : usage %s", tc_table[i].tc_code, tc_table[i].tc_name);
- } else {
+ else
TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
- }
i++;
}
TC_PRT("TC : %s[%d]", tc_table[test_id].tc_name, tc_table[test_id].tc_code);
switch (tc_table[test_id].tc_code) {
- case 0x00ff:
- TC_PRT("Finished");
- g_main_loop_quit(main_loop);
- break;
+ case 0x00ff:
+ TC_PRT("Finished");
+ g_main_loop_quit(main_loop);
+ break;
+
+ case 1:
+ bluetooth_register_callback(bt_event_callback, NULL);
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[0].tc_name, ret);
+ tc_result(TC_FAIL, 1);
+ }
+ break;
+
+ case 2:
+ bluetooth_unregister_callback();
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[1].tc_name, ret);
+ tc_result(TC_FAIL, 1);
+ }
+ break;
+
+ case 3:
+ ret = bluetooth_enable_adapter();
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[2].tc_name, ret);
+ tc_result(TC_FAIL, 1);
+ }
+ break;
+
+ case 4:
+ ret = bluetooth_disable_adapter();
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[3].tc_name, ret);
+ tc_result(TC_FAIL, 2);
+ }
+ break;
+
+ case 5:
+ {
+ ret = bluetooth_check_adapter();
+ TC_PRT("state: %d", ret);
+ break;
+ }
- case 1:
- bluetooth_register_callback(bt_event_callback, NULL);
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[0].tc_name, ret);
- tc_result(TC_FAIL, 1);
- }
- break;
+ case 6:
+ {
+ bluetooth_device_address_t address = { {0} };
+ ret = bluetooth_get_local_address(&address);
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[5].tc_name, ret);
+ } else {
+ TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
+ address.addr[0], address.addr[1], address.addr[2], \
+ address.addr[3], address.addr[4], address.addr[5]);
+ }
+ break;
+ }
- case 2:
- bluetooth_unregister_callback();
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[1].tc_name, ret);
- tc_result(TC_FAIL, 1);
- }
- break;
+ case 7:
+ {
+ bluetooth_device_name_t local_name = { {0} };
+ ret = bluetooth_get_local_name(&local_name);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[6].tc_name, ret);
+ else
+ TC_PRT("name: %s", local_name.name);
- case 3:
- ret = bluetooth_enable_adapter();
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[2].tc_name, ret);
- tc_result(TC_FAIL, 1);
- }
- break;
+ break;
+ }
- case 4:
- ret = bluetooth_disable_adapter();
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[3].tc_name, ret);
- tc_result(TC_FAIL, 2);
- }
- break;
+ case 8:
+ {
+ bluetooth_device_name_t local_name = { {0} };
+ snprintf(local_name.name, sizeof(local_name.name),
+ "bt-frwk-pid-%d", getpid());
+ ret = bluetooth_set_local_name(&local_name);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[7].tc_name, ret);
- case 5:
- {
- ret = bluetooth_check_adapter();
- TC_PRT("state: %d", ret);
- break;
- }
+ break;
+ }
- case 6:
- {
- bluetooth_device_address_t address = { {0} };
- ret = bluetooth_get_local_address(&address);
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[5].tc_name, ret);
- } else {
- TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
- address.addr[0], address.addr[1], address.addr[2], \
- address.addr[3], address.addr[4], address.addr[5]);
- }
- break;
- }
+ case 90:
+ {
+ bluetooth_version_t local_version = { {0} };
+ snprintf(local_version.version, sizeof(local_version.version),
+ "version%d", getpid());
+ ret = bluetooth_get_local_version(&local_version);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[89].tc_name, ret);
+ else
+ TC_PRT("version: %s", local_version.version);
+ break;
+ }
- case 7:
- {
- bluetooth_device_name_t local_name = { {0} };
+ case 9:
+ {
+ gboolean used = FALSE;
+ ret = bluetooth_is_service_used(rfcomm_test_uuid_spp, &used);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[8].tc_name, ret);
+ else
+ TC_PRT("used: %d", used);
+ break;
+ }
- ret = bluetooth_get_local_name(&local_name);
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[6].tc_name, ret);
- } else {
- TC_PRT("name: %s", local_name.name);
- }
- break;
- }
+ case 10:
+ {
+ bluetooth_discoverable_mode_t mode;
+ ret = bluetooth_get_discoverable_mode(&mode);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[9].tc_name, ret);
+ else
+ TC_PRT("BT Get Discoverable mode [%d]", mode);
+ break;
+ }
- case 8:
- {
- bluetooth_device_name_t local_name = { {0} };
- snprintf(local_name.name, sizeof(local_name.name),
- "bt-frwk-pid-%d", getpid());
+ case 11:
+ {
+ bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+ ret = bluetooth_set_discoverable_mode(mode, 0);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[10].tc_name, ret);
+ else
+ TC_PRT("BT Set Discoverable mode [%d]", mode);
+ break;
+ }
- ret = bluetooth_set_local_name(&local_name);
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[7].tc_name, ret);
- }
- break;
- }
+ case 12:
+ {
+ bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
+ ret = bluetooth_set_discoverable_mode(mode, 0);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[11].tc_name, ret);
+ else
+ TC_PRT("BT Set Discoverable mode [%d]", mode);
+ break;
+ }
- case 90:
- {
- bluetooth_version_t local_version = { {0} };
- snprintf(local_version.version, sizeof(local_version.version),
- "version%d", getpid());
+ case 13:
+ {
+ bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
+ ret = bluetooth_set_discoverable_mode(mode, 5);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[12].tc_name, ret);
+ else
+ TC_PRT("BT Set Discoverable mode [%d]", mode);
+ break;
+ }
- ret = bluetooth_get_local_version(&local_version);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[89].tc_name, ret);
- else
- TC_PRT("version: %s", local_version.version);
- break;
- }
+ case 14:
+ ret = bluetooth_start_discovery(0, 0, 0);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[13].tc_name, ret);
+ break;
+
+ case 15:
+ ret = bluetooth_cancel_discovery();
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[14].tc_name, ret);
+ break;
+
+ case 16:
+ {
+ ret = bluetooth_is_discovering();
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[15].tc_name, ret);
+ else
+ TC_PRT("Discovering [%d]", ret);
+ break;
+ }
- case 9:
- {
- gboolean used = FALSE;
+ case 17: /*Get paired device list */
+ {
+ GPtrArray *devinfo = NULL;
+ devinfo = g_ptr_array_new();
+ TC_PRT("g pointer arrary count : [%d]", devinfo->len);
- ret = bluetooth_is_service_used(rfcomm_test_uuid_spp, &used);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[8].tc_name, ret);
- else
- TC_PRT("used: %d", used);
- break;
+ ret = bluetooth_get_bonded_device_list(&devinfo);
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[16].tc_name, ret);
+ } else {
+ int i;
+ bluetooth_device_info_t *ptr;
+ TC_PRT("g pointer arrary count : [%d]", devinfo->len);
+ for (i = 0; i < devinfo->len; i++) {
+ ptr = g_ptr_array_index(devinfo, i);
+ if (ptr != NULL) {
+ TC_PRT("Name [%s]", ptr->device_name.name);
+ TC_PRT("Major Class [%d]", ptr->device_class.major_class);
+ TC_PRT("Minor Class [%d]", ptr->device_class.minor_class);
+ TC_PRT("Service Class [%d]", ptr->device_class.service_class);
+ TC_PRT("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", ptr->device_address.addr[0], ptr->device_address.addr[1], ptr->device_address.addr[2], ptr->device_address.addr[3], ptr->device_address.addr[4], ptr->device_address.addr[5]);
+ TC_PRT("\n");
+ }
+ }
}
+ g_ptr_array_free(devinfo, TRUE);
- case 10:
- {
- bluetooth_discoverable_mode_t mode;
- ret = bluetooth_get_discoverable_mode(&mode);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[9].tc_name, ret);
- else
- TC_PRT("BT Get Discoverable mode [%d]", mode);
- break;
- }
+ break;
+ }
- case 11:
- {
- bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
- ret = bluetooth_set_discoverable_mode(mode, 0);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[10].tc_name, ret);
- else
- TC_PRT("BT Set Discoverable mode [%d]", mode);
+ case 18:
+ {
+ bluetooth_device_address_t device_address = { {0xDC, 0x2C, 0x26, 0xD0, 0xF3, 0xC1} }; /* BT Keyboard */
+ TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
+ device_address.addr[0], device_address.addr[1], device_address.addr[2], \
+ device_address.addr[3], device_address.addr[4], device_address.addr[5]);
+ ret = bluetooth_bond_device(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[17].tc_name, ret);
break;
- }
+ }
- case 12:
- {
- bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
- ret = bluetooth_set_discoverable_mode(mode, 0);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[11].tc_name, ret);
- else
- TC_PRT("BT Set Discoverable mode [%d]", mode);
+ case 19: /*Cancel bonding */
+ {
+ ret = bluetooth_cancel_bonding();
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[18].tc_name, ret);
break;
- }
+ }
- case 13:
- {
- bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
- ret = bluetooth_set_discoverable_mode(mode, 5);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[12].tc_name, ret);
- else
- TC_PRT("BT Set Discoverable mode [%d]", mode);
+ case 20: /*unbonding */
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x19, 0x0E, 0x01, 0x61, 0x17} }; /* DO-DH79-PYUN04 */
+ ret = bluetooth_unbond_device(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[19].tc_name, ret);
break;
+ }
+
+ case 21: /*Get paired device */
+ {
+ bluetooth_device_info_t devinfo;
+ bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ memset(&devinfo, 0x00, sizeof(bluetooth_device_info_t));
+ ret = bluetooth_get_bonded_device(&device_address, &devinfo);
+ if (ret != BLUETOOTH_ERROR_NONE) {
+ TC_PRT("bluetooth_get_bonded_device failed with [%d]", ret);
+ } else {
+ TC_PRT("Name [%s]", devinfo.device_name.name);
+ TC_PRT("Major Class [%d]", devinfo.device_class.major_class);
+ TC_PRT("Minor Class [%d]", devinfo.device_class.minor_class);
+ TC_PRT("Service Class [%d]", devinfo.device_class.service_class);
+ TC_PRT("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", devinfo.device_address.addr[0], devinfo.device_address.addr[1], devinfo.device_address.addr[2], devinfo.device_address.addr[3], devinfo.device_address.addr[4], devinfo.device_address.addr[5]);
}
- case 14:
- ret = bluetooth_start_discovery(0, 0, 0);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[13].tc_name, ret);
- break;
+ break;
+ }
- case 15:
- ret = bluetooth_cancel_discovery();
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[14].tc_name, ret);
- break;
+ case 22: /*set alias for bonded device */
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
- case 16:
- {
- ret = bluetooth_is_discovering();
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[15].tc_name, ret);
- else
- TC_PRT("Discovering [%d]", ret);
- break;
- }
+ ret = bluetooth_set_alias(&device_address, "Renamed device");
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[21].tc_name, ret);
- case 17: /*Get paired device list */
- {
- GPtrArray *devinfo = NULL;
- devinfo = g_ptr_array_new();
- TC_PRT("g pointer arrary count : [%d]", devinfo->len);
+ break;
+ }
- ret = bluetooth_get_bonded_device_list(&devinfo);
- if (ret < 0) {
- TC_PRT("%s failed with [0x%04x]", tc_table[16].tc_name, ret);
- } else {
- int i;
- bluetooth_device_info_t *ptr;
- TC_PRT("g pointer arrary count : [%d]", devinfo->len);
+ case 23:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ ret = bluetooth_authorize_device(&device_address, TRUE);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[22].tc_name, ret);
- for (i = 0; i < devinfo->len; i++) {
- ptr = g_ptr_array_index(devinfo, i);
- if (ptr != NULL) {
- TC_PRT("Name [%s]", ptr->device_name.name);
- TC_PRT("Major Class [%d]", ptr->device_class.major_class);
- TC_PRT("Minor Class [%d]", ptr->device_class.minor_class);
- TC_PRT("Service Class [%d]", ptr->device_class.service_class);
- TC_PRT("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", ptr->device_address.addr[0], ptr->device_address.addr[1], ptr->device_address.addr[2], ptr->device_address.addr[3], ptr->device_address.addr[4], ptr->device_address.addr[5]);
- TC_PRT("\n");
- }
- }
- }
- g_ptr_array_free(devinfo, TRUE);
+ break;
+ }
+ case 24:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ ret = bluetooth_authorize_device(&device_address, FALSE);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[23].tc_name, ret);
break;
- }
+ }
+ case 25:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
- case 18:
- {
- bluetooth_device_address_t device_address = { {0xDC, 0x2C, 0x26, 0xD0, 0xF3, 0xC1} }; /* BT Keyboard */
+ ret = bluetooth_search_service(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
- TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
- device_address.addr[0], device_address.addr[1], device_address.addr[2], \
- device_address.addr[3], device_address.addr[4], device_address.addr[5]);
+ break;
+ }
- ret = bluetooth_bond_device(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[17].tc_name, ret);
- break;
+ case 26:
+ {
+ ret = bluetooth_cancel_service_search();
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
+ break;
+ }
+
+ case 27:
+ {
+ gboolean connected = FALSE;
+ bluetooth_device_address_t device_address = { {0x00, 0x1B, 0x66, 0x01, 0x23, 0x1C} }; /* Gennheiser PX210BT */
+
+ ret = bluetooth_is_device_connected(&device_address, BLUETOOTH_A2DP_SERVICE, &connected);
+ if (ret < 0) {
+ TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
+ TC_PRT("connected : %d", connected);
}
+ break;
+ }
- case 19: /*Cancel bonding */
- {
- ret = bluetooth_cancel_bonding();
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[18].tc_name, ret);
+ case 28:
+ {
+ ret = bluetooth_reset_adapter();
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[27].tc_name, ret);
- break;
- }
+ break;
+ }
- case 20: /*unbonding */
- {
- bluetooth_device_address_t device_address = { {0x00, 0x19, 0x0E, 0x01, 0x61, 0x17} }; /* DO-DH79-PYUN04 */
- ret = bluetooth_unbond_device(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[19].tc_name, ret);
+ case 91:
+ {
+ bluetooth_manufacturer_data_t m_data;
+ guint8 data[6] = {0x05, 0xFF, 0x02, 0x03, 0x04, 0x05};
+ TC_PRT("%x %x %x %x %x %x", data[0], data[1], data[2], data[3],
+ data[4], data[5]);
+
+ memcpy(m_data.data, data, sizeof(data));
+ m_data.data_len = sizeof(data) - 2;
+ ret = bluetooth_set_manufacturer_data(&m_data);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[90].tc_name, ret);
+ break;
+ }
- break;
- }
+ case 29:
+ {
+ ret = bluetooth_audio_init(bt_audio_event_callback, NULL);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[28].tc_name, ret);
- case 21: /*Get paired device */
- {
- bluetooth_device_info_t devinfo;
- bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ break;
+ }
- memset(&devinfo, 0x00, sizeof(bluetooth_device_info_t));
+ case 30:
+ {
+ ret = bluetooth_audio_deinit();
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[29].tc_name, ret);
- ret = bluetooth_get_bonded_device(&device_address, &devinfo);
- if (ret != BLUETOOTH_ERROR_NONE) {
- TC_PRT("bluetooth_get_bonded_device failed with [%d]", ret);
- } else {
- TC_PRT("Name [%s]", devinfo.device_name.name);
- TC_PRT("Major Class [%d]", devinfo.device_class.major_class);
- TC_PRT("Minor Class [%d]", devinfo.device_class.minor_class);
- TC_PRT("Service Class [%d]", devinfo.device_class.service_class);
- TC_PRT("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", devinfo.device_address.addr[0], devinfo.device_address.addr[1], devinfo.device_address.addr[2], devinfo.device_address.addr[3], devinfo.device_address.addr[4], devinfo.device_address.addr[5]);
- }
+ break;
+ }
- break;
- }
+ case 31:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
- case 22: /*set alias for bonded device */
- {
- bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ ret = bluetooth_audio_connect(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[30].tc_name, ret);
- ret = bluetooth_set_alias(&device_address, "Renamed device");
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[21].tc_name, ret);
- break;
- }
+ break;
+ }
- case 23:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ case 32:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
- ret = bluetooth_authorize_device(&device_address, TRUE);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[22].tc_name, ret);
- break;
- }
- case 24:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ ret = bluetooth_audio_disconnect(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[31].tc_name, ret);
+ break;
+ }
- ret = bluetooth_authorize_device(&device_address, FALSE);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[23].tc_name, ret);
- break;
- }
- case 25:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
+ case 33:
+ {
+ /* MW600 */
+ bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
- ret = bluetooth_search_service(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
- break;
- }
- case 26:
- {
- ret = bluetooth_cancel_service_search();
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
- break;
- }
- case 27:
- {
- gboolean connected = FALSE;
- bluetooth_device_address_t device_address = { {0x00, 0x1B, 0x66, 0x01, 0x23, 0x1C} }; /* Gennheiser PX210BT */
+ ret = bluetooth_ag_connect(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[32].tc_name, ret);
+ break;
+ }
+ case 34:
+ {
+ /* MW600 */
+ bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
+
+ ret = bluetooth_ag_disconnect(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[33].tc_name, ret);
+ break;
+ }
- ret = bluetooth_is_device_connected(&device_address, BLUETOOTH_A2DP_SERVICE, &connected);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
+ case 35:
+ {
+ /* MW600 */
+ bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
- TC_PRT("connected : %d", connected);
- break;
- }
- case 28:
- {
- ret = bluetooth_reset_adapter();
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[27].tc_name, ret);
- break;
- }
- case 91:
- {
- bluetooth_manufacturer_data_t m_data;
- guint8 data[6] = {0x05, 0xFF, 0x02, 0x03, 0x04, 0x05};
-
- TC_PRT("%x %x %x %x %x %x", data[0], data[1], data[2], data[3],
- data[4], data[5]);
- memcpy(m_data.data, data, sizeof(data));
- m_data.data_len = sizeof(data) - 2;
- ret = bluetooth_set_manufacturer_data(&m_data);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[90].tc_name, ret);
- break;
- }
- case 29:
- {
- ret = bluetooth_audio_init(bt_audio_event_callback, NULL);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[28].tc_name, ret);
- break;
- }
- case 30:
- {
- ret = bluetooth_audio_deinit();
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[29].tc_name, ret);
- break;
- }
- case 31:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
+ ret = bluetooth_av_connect(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[34].tc_name, ret);
+ break;
+ }
- ret = bluetooth_audio_connect(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[30].tc_name, ret);
- break;
- }
- case 32:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
+ case 36:
+ {
+ /* MW600 */
+ bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
- ret = bluetooth_audio_disconnect(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[31].tc_name, ret);
- break;
- }
- case 33:
- {
- /* MW600 */
- bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
-
- ret = bluetooth_ag_connect(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[32].tc_name, ret);
- break;
- }
- case 34:
- {
- /* MW600 */
- bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
-
- ret = bluetooth_ag_disconnect(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[33].tc_name, ret);
- break;
- }
- case 35:
- {
- /* MW600 */
- bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
-
- ret = bluetooth_av_connect(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[34].tc_name, ret);
- break;
- }
- case 36:
- {
- /* MW600 */
- bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
-
- ret = bluetooth_av_disconnect(&device_address);
- if (ret < 0)
- TC_PRT("%s failed with [0x%04x]", tc_table[35].tc_name, ret);
- break;
- }
- case 37:
- {
- unsigned int volume = 0;
+ ret = bluetooth_av_disconnect(&device_address);
+ if (ret < 0)
+ TC_PRT("%s failed with [0x%04x]", tc_table[35].tc_name, ret);
- ret = bluetooth_ag_get_headset_volume(&volume);
- if (ret < 0)
- TC_PRT("failed with [0x%04x]", ret);
+ break;
+ }
+
+ case 37:
+ {
+ unsigned int volume = 0;
+ ret = bluetooth_ag_get_headset_volume(&volume);
+ if (ret < 0) {
+ TC_PRT("failed with [0x%04x]", ret);
TC_PRT("volume: %d", volume);
- break;
- }
- case 38:
- {
- ret = bluetooth_ag_set_speaker_gain(10);
- if (ret < 0)
- TC_PRT("failed with [0x%04x]", ret);
- break;
}
- case 39:
- {
- if (bluetooth_oob_read_local_data(&g_local_oob_data.oob_data)) {
- TC_PRT("ERROR in bluetooth_oob_read_local_data\n");
- } else {
- TC_PRT("SUCESS in bluetooth_oob_read_local_data\n");
- TC_PRT("hash = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
- "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
- g_local_oob_data.oob_data.hash[0],
- g_local_oob_data.oob_data.hash[1],
- g_local_oob_data.oob_data.hash[2],
- g_local_oob_data.oob_data.hash[3],
- g_local_oob_data.oob_data.hash[4],
- g_local_oob_data.oob_data.hash[5],
- g_local_oob_data.oob_data.hash[6],
- g_local_oob_data.oob_data.hash[7],
- g_local_oob_data.oob_data.hash[8],
- g_local_oob_data.oob_data.hash[9],
- g_local_oob_data.oob_data.hash[10],
- g_local_oob_data.oob_data.hash[11],
- g_local_oob_data.oob_data.hash[12],
- g_local_oob_data.oob_data.hash[13],
- g_local_oob_data.oob_data.hash[14],
- g_local_oob_data.oob_data.hash[15]);
-
- TC_PRT("randomizer = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
- "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
- g_local_oob_data.oob_data.randomizer[0],
- g_local_oob_data.oob_data.randomizer[1],
- g_local_oob_data.oob_data.randomizer[2],
- g_local_oob_data.oob_data.randomizer[3],
- g_local_oob_data.oob_data.randomizer[4],
- g_local_oob_data.oob_data.randomizer[5],
- g_local_oob_data.oob_data.randomizer[6],
- g_local_oob_data.oob_data.randomizer[7],
- g_local_oob_data.oob_data.randomizer[8],
- g_local_oob_data.oob_data.randomizer[9],
- g_local_oob_data.oob_data.randomizer[10],
- g_local_oob_data.oob_data.randomizer[11],
- g_local_oob_data.oob_data.randomizer[12],
- g_local_oob_data.oob_data.randomizer[13],
- g_local_oob_data.oob_data.randomizer[14],
- g_local_oob_data.oob_data.randomizer[15]);
-
- TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
- TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
- }
- break;
- }
- case 40:
- {
- ret = bluetooth_get_local_address(&g_local_oob_data.address);
+ break;
+ }
+
+ case 38:
+ {
+ ret = bluetooth_ag_set_speaker_gain(10);
+ if (ret < 0)
+ TC_PRT("failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 39:
+ {
+ if (bluetooth_oob_read_local_data(&g_local_oob_data.oob_data)) {
+ TC_PRT("ERROR in bluetooth_oob_read_local_data\n");
+ } else {
+ TC_PRT("SUCESS in bluetooth_oob_read_local_data\n");
+ TC_PRT("hash = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
+ "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
+ g_local_oob_data.oob_data.hash[0],
+ g_local_oob_data.oob_data.hash[1],
+ g_local_oob_data.oob_data.hash[2],
+ g_local_oob_data.oob_data.hash[3],
+ g_local_oob_data.oob_data.hash[4],
+ g_local_oob_data.oob_data.hash[5],
+ g_local_oob_data.oob_data.hash[6],
+ g_local_oob_data.oob_data.hash[7],
+ g_local_oob_data.oob_data.hash[8],
+ g_local_oob_data.oob_data.hash[9],
+ g_local_oob_data.oob_data.hash[10],
+ g_local_oob_data.oob_data.hash[11],
+ g_local_oob_data.oob_data.hash[12],
+ g_local_oob_data.oob_data.hash[13],
+ g_local_oob_data.oob_data.hash[14],
+ g_local_oob_data.oob_data.hash[15]);
+
+ TC_PRT("randomizer = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
+ "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
+ g_local_oob_data.oob_data.randomizer[0],
+ g_local_oob_data.oob_data.randomizer[1],
+ g_local_oob_data.oob_data.randomizer[2],
+ g_local_oob_data.oob_data.randomizer[3],
+ g_local_oob_data.oob_data.randomizer[4],
+ g_local_oob_data.oob_data.randomizer[5],
+ g_local_oob_data.oob_data.randomizer[6],
+ g_local_oob_data.oob_data.randomizer[7],
+ g_local_oob_data.oob_data.randomizer[8],
+ g_local_oob_data.oob_data.randomizer[9],
+ g_local_oob_data.oob_data.randomizer[10],
+ g_local_oob_data.oob_data.randomizer[11],
+ g_local_oob_data.oob_data.randomizer[12],
+ g_local_oob_data.oob_data.randomizer[13],
+ g_local_oob_data.oob_data.randomizer[14],
+ g_local_oob_data.oob_data.randomizer[15]);
+
TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
-
- if (bluetooth_oob_add_remote_data(&g_local_oob_data.address,
- &g_local_oob_data.oob_data))
- TC_PRT("ERROR in bluetooth_oob_add_remote_data\n");
- else
- TC_PRT(" bluetooth_oob_add_remote_data SUCCESS\n");
- break;
}
- case 41:
- {
- if (bluetooth_oob_remove_remote_data(&g_local_oob_data.address))
- TC_PRT("ERROR in bluetooth_oob_remove_remote_data\n");
- else
- TC_PRT(" bluetooth_oob_remove_remote_data SUCCESS\n");
- break;
- }
- case 42:
- {
- bluetooth_opc_init();
- break;
- }
- case 43:
- {
- bluetooth_opc_deinit();
- break;
- }
- case 44:
- {
- bluetooth_device_address_t remote_address = { {0} };
+ break;
+ }
- /* Grey dongle */
- remote_address.addr[0] = 0x00; remote_address.addr[1] = 0x02; remote_address.addr[2] = 0x70;
- remote_address.addr[3] = 0x2B; remote_address.addr[4] = 0xD3; remote_address.addr[5] = 0xAF;
+ case 40:
+ {
+ ret = bluetooth_get_local_address(&g_local_oob_data.address);
+ TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
+ TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
- char *files[5] = {NULL};
+ if (bluetooth_oob_add_remote_data(&g_local_oob_data.address,
+ &g_local_oob_data.oob_data))
+ TC_PRT("ERROR in bluetooth_oob_add_remote_data\n");
+ else
+ TC_PRT(" bluetooth_oob_add_remote_data SUCCESS\n");
- files[0] = "/opt/media/Images/image1.jpg";
-// files[1] = "/opt/media/Images/image2.jpg";
-// files[2] = "/opt/media/Images/image3.jpg";
- bluetooth_opc_push_files(&remote_address, files);
- break;
- }
- case 45:
- {
- bluetooth_opc_cancel_push();
- break;
- }
- case 46:
- {
- gboolean exist;
- exist = bluetooth_opc_session_is_exist();
- TC_PRT("exist: %d", exist);
- break;
- }
- case 47:
- {
- bluetooth_network_activate_server();
- break;
- }
- case 48:
- {
- bluetooth_network_deactivate_server();
- break;
- }
- case 49:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
- bluetooth_network_connect(&device_address, BLUETOOTH_NETWORK_NAP_ROLE, NULL);
- break;
- }
- case 50:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
- bluetooth_network_disconnect(&device_address);
- break;
- }
- case 51:
- {
- bluetooth_obex_server_init("/opt/media/Downloads");
- break;
- }
- case 52:
- {
- bluetooth_obex_server_deinit();
- break;
- }
- case 53:
- {
- bluetooth_obex_server_init_without_agent("/opt/media/Downloads");
- break;
- }
- case 54:
- {
- bluetooth_obex_server_deinit_without_agent();
- break;
- }
- case 55:
- {
- bluetooth_obex_server_is_activated();
- break;
- }
- case 56:
- {
- bluetooth_obex_server_accept_connection();
- TC_PRT(" bluetooth_obex_server_accept_connection SUCCESS\n");
- break;
- }
- case 57:
- {
- bluetooth_obex_server_reject_connection();
- break;
- }
- case 58:
- {
- bluetooth_obex_server_accept_authorize("abc");
- break;
- }
- case 59:
- {
- bluetooth_obex_server_reject_authorize();
- break;
- }
- case 60:
- {
- bluetooth_obex_server_set_destination_path("/opt/media");
- break;
- }
- case 61:
- {
- bluetooth_obex_server_set_root("/opt/media");
- break;
- }
- case 62:
- {
- bluetooth_obex_server_cancel_transfer(0);
- break;
- }
- case 63:
- {
- bluetooth_obex_server_cancel_all_transfers();
- break;
- }
+ break;
+ }
- case 65:
- {
- ret = bluetooth_hid_init(bt_hid_event_callback, NULL);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 66:
- {
- ret = bluetooth_hid_deinit();
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 67:
- {
- /* Apple wireless keyboard */
- hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
-
- ret = bluetooth_hid_connect(&device_address);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 68:
- {
- /* Apple wireless keyboard */
- hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
-
- ret = bluetooth_hid_disconnect(&device_address);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
+ case 41:
+ {
+ if (bluetooth_oob_remove_remote_data(&g_local_oob_data.address))
+ TC_PRT("ERROR in bluetooth_oob_remove_remote_data\n");
+ else
+ TC_PRT(" bluetooth_oob_remove_remote_data SUCCESS\n");
+ break;
+ }
- case 70:
- {
- bluetooth_device_address_t device_address = { {0x00, 0x02, 0x2F, 0x92, 0x7B, 0xF5} };
+ case 42:
+ {
+ bluetooth_opc_init();
+ break;
+ }
- ret = bluetooth_rfcomm_connect(&device_address, rfcomm_test_uuid_spp);
- //ret = bluetooth_rfcomm_connect(&device_address, "1");
+ case 43:
+ {
+ bluetooth_opc_deinit();
+ break;
+ }
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 71:
- {
- ret = bluetooth_rfcomm_disconnect(-1);
+ case 44:
+ {
+ bluetooth_device_address_t remote_address = { {0} };
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 72:
- {
- ret = bluetooth_rfcomm_disconnect(g_ret_client_fd1);
+ /* Grey dongle */
+ remote_address.addr[0] = 0x00; remote_address.addr[1] = 0x02; remote_address.addr[2] = 0x70;
+ remote_address.addr[3] = 0x2B; remote_address.addr[4] = 0xD3; remote_address.addr[5] = 0xAF;
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 73:
- {
- const char rd_data[] = "123456789 12345";
- ret = bluetooth_rfcomm_write(g_ret_client_fd1, rd_data, sizeof(rd_data));
+ char *files[5] = {NULL};
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 74:
- {
- gboolean is_connected;
+ files[0] = "/opt/media/Images/image1.jpg";
+// files[1] = "/opt/media/Images/image2.jpg";
+// files[2] = "/opt/media/Images/image3.jpg";
+ bluetooth_opc_push_files(&remote_address, files);
+ break;
+ }
+
+ case 45:
+ {
+ bluetooth_opc_cancel_push();
+ break;
+ }
- is_connected = bluetooth_rfcomm_is_client_connected();
+ case 46:
+ {
+ gboolean exist;
+ exist = bluetooth_opc_session_is_exist();
+ TC_PRT("exist: %d", exist);
+ break;
+ }
- TC_PRT("Connected: %d", is_connected);
- break;
- }
- case 80:
- {
- ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_spp);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
+ case 47:
+ {
+ bluetooth_network_activate_server();
+ break;
+ }
+
+ case 48:
+ {
+ bluetooth_network_deactivate_server();
+ break;
+ }
+
+ case 49:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
+ bluetooth_network_connect(&device_address, BLUETOOTH_NETWORK_NAP_ROLE, NULL);
+ break;
+ }
+
+ case 50:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
+ bluetooth_network_disconnect(&device_address);
+ break;
+ }
+
+ case 51:
+ {
+ bluetooth_obex_server_init("/opt/media/Downloads");
+ break;
+ }
+
+ case 52:
+ {
+ bluetooth_obex_server_deinit();
+ break;
+ }
+
+ case 53:
+ {
+ bluetooth_obex_server_init_without_agent("/opt/media/Downloads");
+ break;
+ }
+
+ case 54:
+ {
+ bluetooth_obex_server_deinit_without_agent();
+ break;
+ }
+
+ case 55:
+ {
+ bluetooth_obex_server_is_activated();
+ break;
+ }
+
+ case 56:
+ {
+ bluetooth_obex_server_accept_connection();
+ TC_PRT(" bluetooth_obex_server_accept_connection SUCCESS\n");
+ break;
+ }
+
+ case 57:
+ {
+ bluetooth_obex_server_reject_connection();
+ break;
+ }
+
+ case 58:
+ {
+ bluetooth_obex_server_accept_authorize("abc");
+ break;
+ }
+ case 59:
+ {
+ bluetooth_obex_server_reject_authorize();
+ break;
+ }
+
+ case 60:
+ {
+ bluetooth_obex_server_set_destination_path("/opt/media");
+ break;
+ }
+
+ case 61:
+ {
+ bluetooth_obex_server_set_root("/opt/media");
+ break;
+ }
+
+ case 62:
+ {
+ bluetooth_obex_server_cancel_transfer(0);
+ break;
+ }
+
+ case 63:
+ {
+ bluetooth_obex_server_cancel_all_transfers();
+ break;
+ }
+
+ case 65:
+ {
+ ret = bluetooth_hid_init(bt_hid_event_callback, NULL);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 66:
+ {
+ ret = bluetooth_hid_deinit();
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 67:
+ {
+ /* Apple wireless keyboard */
+ hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
+
+ ret = bluetooth_hid_connect(&device_address);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 68:
+ {
+ /* Apple wireless keyboard */
+ hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
+
+ ret = bluetooth_hid_disconnect(&device_address);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 70:
+ {
+ bluetooth_device_address_t device_address = { {0x00, 0x02, 0x2F, 0x92, 0x7B, 0xF5} };
+
+ ret = bluetooth_rfcomm_connect(&device_address, rfcomm_test_uuid_spp);
+ //ret = bluetooth_rfcomm_connect(&device_address, "1");
+
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 71:
+ {
+ ret = bluetooth_rfcomm_disconnect(-1);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 72:
+ {
+ ret = bluetooth_rfcomm_disconnect(g_ret_client_fd1);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 73:
+ {
+ const char rd_data[] = "123456789 12345";
+ ret = bluetooth_rfcomm_write(g_ret_client_fd1, rd_data, sizeof(rd_data));
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 74:
+ {
+ gboolean is_connected;
+ is_connected = bluetooth_rfcomm_is_client_connected();
+ TC_PRT("Connected: %d", is_connected);
+
+ break;
+ }
+
+ case 80:
+ {
+ ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_spp);
+ if (ret < 0) {
+ TC_PRT("Failed with [0x%04x]", ret);
TC_PRT("Returned FD = %d", ret);
- server_fd = ret;
- break;
}
- case 81:
- {
- ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_custom);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
+ server_fd = ret;
+
+ break;
+ }
+ case 81:
+ {
+ ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_custom);
+ if (ret < 0) {
+ TC_PRT("Failed with [0x%04x]", ret);
TC_PRT("Returned FD = %d", ret);
- server_fd = ret;
- break;
- }
- case 82:
- {
- ret = bluetooth_rfcomm_remove_socket(server_fd);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
}
- case 83: /*Listen and accept */
- {
+ server_fd = ret;
- ret = bluetooth_rfcomm_listen_and_accept(server_fd, 1);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
+ break;
+ }
+ case 82:
+ {
+ ret = bluetooth_rfcomm_remove_socket(server_fd);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 83: /*Listen and accept */
+ {
+ ret = bluetooth_rfcomm_listen_and_accept(server_fd, 1);
+ if (ret < 0) {
+ TC_PRT("Failed with [0x%04x]", ret);
TC_PRT("result = %d", ret);
- break;
}
- case 84: /*Listen */
- {
- ret = bluetooth_rfcomm_listen(server_fd, 1);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
+ break;
+ }
+ case 84: /*Listen */
+ {
+ ret = bluetooth_rfcomm_listen(server_fd, 1);
+ if (ret < 0) {
+ TC_PRT("Failed with [0x%04x]", ret);
TC_PRT("result = %d", ret);
- break;
- }
- case 85:
- {
- ret = bluetooth_rfcomm_server_disconnect(client_fd);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
}
- case 86:
- {
- gboolean available;
- available = bluetooth_rfcomm_is_server_uuid_available(rfcomm_test_uuid_spp);
+ break;
+ }
- TC_PRT("available: %d", available);
- break;
- }
- case 87:
- {
- ret = bluetooth_rfcomm_accept_connection(server_fd);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
+ case 85:
+ {
+ ret = bluetooth_rfcomm_server_disconnect(client_fd);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+
+ break;
+ }
+
+ case 86:
+ {
+ gboolean available;
+ available = bluetooth_rfcomm_is_server_uuid_available(rfcomm_test_uuid_spp);
+ TC_PRT("available: %d", available);
+
+ break;
+ }
+
+ case 87:
+ {
+ ret = bluetooth_rfcomm_accept_connection(server_fd);
+ if (ret < 0) {
+ TC_PRT("Failed with [0x%04x]", ret);
TC_PRT("client fd: %d", client_fd);
- break;
- }
- case 88:
- {
- ret = bluetooth_rfcomm_reject_connection(server_fd);
- if (ret < 0)
- TC_PRT("Failed with [0x%04x]", ret);
- break;
- }
- case 89:
- ret = bluetooth_start_custom_discovery(DISCOVERY_ROLE_LE,
- 0, 0, 0);
- if (ret < 0)
- TC_PRT("failed with [0x%04x]", ret);
- break;
- case 92: {
- ret = bluetooth_gatt_init();
- if (ret < 0)
- TC_PRT("gatt init failed with [0x%04x]", ret);
- break;
}
- case 93: {
- ret = bluetooth_gatt_deinit();
- if (ret < 0)
- TC_PRT("gatt deinit failed with [0x%04x]", ret);
- break;
- }
- case 94: {
- char *service_uuid = g_strdup("00001802-0000-1000-8000-00805f9b34fb");
- ret = bluetooth_gatt_add_service(service_uuid,
- &svc_obj_path);
+ break;
+ }
- TC_PRT("service obj_path is %s", svc_obj_path);
- }
- break;
+ case 88:
+ {
+ ret = bluetooth_rfcomm_reject_connection(server_fd);
+ if (ret < 0)
+ TC_PRT("Failed with [0x%04x]", ret);
+ break;
+ }
- case 95: {
- /* testing with dummy values*/
- char *char_uuid = g_strdup("00002a06-0000-1000-8000-00805f9b34fb");
- bt_gatt_permission_t perms = 0;
- bt_gatt_characteristic_property_t props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
- BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE |
- BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY |
- BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
+ case 89:
+ ret = bluetooth_start_custom_discovery(DISCOVERY_ROLE_LE,
+ 0, 0, 0);
+ if (ret < 0)
+ TC_PRT("failed with [0x%04x]", ret);
- ret = bluetooth_gatt_add_new_characteristic(
- svc_obj_path, char_uuid,
- perms, props, &char_obj_path);
+ break;
- TC_PRT("characteristic obj_path is %s", char_obj_path);
+ case 92:
+ {
+ ret = bluetooth_gatt_init();
+ if (ret < 0)
+ TC_PRT("gatt init failed with [0x%04x]", ret);
+ break;
+ }
- break;
- }
+ case 93:
+ {
+ ret = bluetooth_gatt_deinit();
+ if (ret < 0)
+ TC_PRT("gatt deinit failed with [0x%04x]", ret);
- case 96: {
- char *desc_uuid = g_strdup("000026ff-0000-1000-8000-00805f9b34fb");
- bt_gatt_permission_t perms = BLUETOOTH_GATT_PERMISSION_READ |
- BLUETOOTH_GATT_PERMISSION_WRITE;
+ break;
+ }
- ret = bluetooth_gatt_add_descriptor(char_obj_path,
- desc_uuid, perms, &desc_obj_path);
+ case 94:
+ {
+ char *service_uuid = g_strdup("00001802-0000-1000-8000-00805f9b34fb");
- TC_PRT("add descriptor error is %d", ret);
+ ret = bluetooth_gatt_add_service(service_uuid,
+ &svc_obj_path);
- break;
- }
- case 97: {
- ret = bluetooth_gatt_register_service(svc_obj_path);
+ TC_PRT("service obj_path is %s", svc_obj_path);
- TC_PRT("register service error is %d", ret);
+ break;
+ }
- break;
- }
- case 98: {
- ret = bluetooth_gatt_register_application();
+ case 95:
+ {
+ /* testing with dummy values*/
+ char *char_uuid = g_strdup("00002a06-0000-1000-8000-00805f9b34fb");
+ bt_gatt_permission_t perms = 0;
+ bt_gatt_characteristic_property_t props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
+ BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE |
+ BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY |
+ BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
- TC_PRT("register service error is %d", ret);
+ ret = bluetooth_gatt_add_new_characteristic(
+ svc_obj_path, char_uuid,
+ perms, props, &char_obj_path);
- break;
- }
- case 99: {
- char char_data[4] = {10, 20, 30, 40};
- int char_length = 4;
- ret = bluetooth_gatt_update_characteristic(char_obj_path,
- char_data, char_length);
+ TC_PRT("characteristic obj_path is %s", char_obj_path);
- TC_PRT("update_characteristic error is %d", ret);
+ break;
+ }
- break;
- }
- case 100: {
- ret = bluetooth_gatt_unregister_service(svc_obj_path);
+ case 96: {
+ char *desc_uuid = g_strdup("000026ff-0000-1000-8000-00805f9b34fb");
+ bt_gatt_permission_t perms = BLUETOOTH_GATT_PERMISSION_READ |
+ BLUETOOTH_GATT_PERMISSION_WRITE;
- TC_PRT("service removed with error is %d", ret);
+ ret = bluetooth_gatt_add_descriptor(char_obj_path,
+ desc_uuid, perms, &desc_obj_path);
+ TC_PRT("add descriptor error is %d", ret);
- break;
- }
- case 101: {
- ret = bluetooth_gatt_delete_services();
+ break;
+ }
- TC_PRT("services deleted with error is %d", ret);
+ case 97: {
+ ret = bluetooth_gatt_register_service(svc_obj_path);
+ TC_PRT("register service error is %d", ret);
- break;
- }
- default:
- break;
+ break;
+ }
+
+ case 98: {
+ ret = bluetooth_gatt_register_application();
+
+ TC_PRT("register service error is %d", ret);
+
+ break;
+ }
+
+ case 99: {
+ char char_data[4] = {10, 20, 30, 40};
+ int char_length = 4;
+ ret = bluetooth_gatt_update_characteristic(char_obj_path,
+ char_data, char_length);
+
+ TC_PRT("update_characteristic error is %d", ret);
+
+ break;
+ }
+
+ case 100: {
+ ret = bluetooth_gatt_unregister_service(svc_obj_path);
+ TC_PRT("service removed with error is %d", ret);
+
+ break;
}
+ case 101:
+ ret = bluetooth_gatt_delete_services();
+ TC_PRT("services deleted with error is %d", ret);
+
+ break;
+
+ default:
+ break;
+ }
return 0;
}
TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
TC_PRT("bt event callback 0x%04x", event);
switch (event) {
- case BLUETOOTH_EVENT_ENABLED:
- TC_PRT("BLUETOOTH_EVENT_ENABLED, result [0x%04x]", param->result);
- break;
+ case BLUETOOTH_EVENT_ENABLED:
+ TC_PRT("BLUETOOTH_EVENT_ENABLED, result [0x%04x]", param->result);
+ break;
+
+ case BLUETOOTH_EVENT_DISABLED:
+ TC_PRT("BLUETOOTH_EVENT_DISABLED, result [0x%04x]", param->result);
+ break;
+
+ case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
+ TC_PRT("BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, result [0x%04x]", param->result);
+ if (param->result == BLUETOOTH_ERROR_NONE) {
+ bluetooth_device_name_t *local_name = (bluetooth_device_name_t *)param->param_data;
+ tc_result(TC_PASS, 6);
+ TC_PRT("Changed Name : [%s]", local_name->name);
+ } else {
+ tc_result(TC_FAIL, 6);
+ }
+ break;
+
+ case BLUETOOTH_EVENT_DISCOVERY_STARTED:
+ TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
+ break;
+
+ case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
+ {
+ bluetooth_device_info_t *device_info = NULL;
+ TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
+ device_info = (bluetooth_device_info_t *)param->param_data;
+ memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
+ TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
+ device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
+ device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
+ break;
+ }
- case BLUETOOTH_EVENT_DISABLED:
- TC_PRT("BLUETOOTH_EVENT_DISABLED, result [0x%04x]", param->result);
- break;
+ case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
+ {
+ int i;
+ bluetooth_le_device_info_t *le_device_info = NULL;
+ TC_PRT("BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, result [0x%04x]", param->result);
+ le_device_info = (bluetooth_le_device_info_t *)param->param_data;
+ TC_PRT("dev[%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
+ le_device_info->device_address.addr[0], le_device_info->device_address.addr[1], le_device_info->device_address.addr[2], \
+ le_device_info->device_address.addr[3], le_device_info->device_address.addr[4], le_device_info->device_address.addr[5]);
+ TC_PRT("addr_type : %d", le_device_info->addr_type);
+ TC_PRT("rssi : %d", le_device_info->rssi);
+ TC_PRT("adv_ind_data_len :%d" , le_device_info->adv_ind_data.data_len);
+ TC_PRT("scan_resp_data_len :%d" , le_device_info->scan_resp_data.data_len);
+ for (i = 0; i < le_device_info->adv_ind_data.data_len; i++)
+ TC_PRT("adv_ind_data[%d] : [0x%x]", i, le_device_info->adv_ind_data.data.data[i]);
+ for (i = 0; i < le_device_info->scan_resp_data.data_len; i++)
+ TC_PRT("scan_resp_data[%d] : [0x%x]", i, le_device_info->scan_resp_data.data.data[i]);
+ break;
+ }
- case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
- TC_PRT("BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, result [0x%04x]", param->result);
- if (param->result == BLUETOOTH_ERROR_NONE) {
- bluetooth_device_name_t *local_name = (bluetooth_device_name_t *)param->param_data;
- tc_result(TC_PASS, 6);
- TC_PRT("Changed Name : [%s]", local_name->name);
- } else {
- tc_result(TC_FAIL, 6);
- }
- break;
+ case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
+ {
+ bluetooth_device_info_t *device_info = NULL;
+ TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
+ device_info = (bluetooth_device_info_t *)param->param_data;
+ memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
+ TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
+ device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
+ device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
+ break;
+ }
+ case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
+ TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
+ break;
- case BLUETOOTH_EVENT_DISCOVERY_STARTED:
- TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
- break;
+ case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
+ {
+ int *mode = (int *)param->param_data;
+ TC_PRT("BT_DISCOVERABLE_MODE_CHANGED, result [0x%04x]", param->result);
+ TC_PRT("mode [%d]", *mode);
+ break;
+ }
- case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
- {
+ case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
+ {
+ int *timeout = (int *)param->param_data;
+ TC_PRT("BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED, result [0x%04x]", param->result);
+ TC_PRT("timeout [%d]", *timeout);
+ break;
+ }
+
+ case BLUETOOTH_EVENT_BONDING_FINISHED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
+ if (param->result >= BLUETOOTH_ERROR_NONE) {
bluetooth_device_info_t *device_info = NULL;
- TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
- device_info = (bluetooth_device_info_t *)param->param_data;
- memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
- TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
- device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
- device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
+ tc_result(TC_PASS, 12);
+ device_info = (bluetooth_device_info_t *)param->param_data;
+ if (device_info == NULL)
break;
+ TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X] mjr[%#x] min[%#x] srv[%#x]", device_info->device_name.name, \
+ device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
+ device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5], \
+ device_info->device_class.major_class, device_info->device_class.minor_class, device_info->device_class.service_class);
+ } else {
+ tc_result(TC_FAIL, 12);
}
+ break;
+ }
- case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
- {
- int i;
- bluetooth_le_device_info_t *le_device_info = NULL;
- TC_PRT("BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, result [0x%04x]", param->result);
- le_device_info = (bluetooth_le_device_info_t *)param->param_data;
- TC_PRT("dev[%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
- le_device_info->device_address.addr[0], le_device_info->device_address.addr[1], le_device_info->device_address.addr[2], \
- le_device_info->device_address.addr[3], le_device_info->device_address.addr[4], le_device_info->device_address.addr[5]);
- TC_PRT("addr_type : %d", le_device_info->addr_type);
- TC_PRT("rssi : %d", le_device_info->rssi);
- TC_PRT("adv_ind_data_len :%d" , le_device_info->adv_ind_data.data_len);
- TC_PRT("scan_resp_data_len :%d" , le_device_info->scan_resp_data.data_len);
-
- for (i = 0; i < le_device_info->adv_ind_data.data_len; i++)
- TC_PRT("adv_ind_data[%d] : [0x%x]", i, le_device_info->adv_ind_data.data.data[i]);
-
- for (i = 0; i < le_device_info->scan_resp_data.data_len; i++)
- TC_PRT("scan_resp_data[%d] : [0x%x]", i, le_device_info->scan_resp_data.data.data[i]);
+ case BLUETOOTH_EVENT_BONDED_DEVICE_FOUND:
+ {
+ // bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
+ // 2011.01.06
+#if 0
+// int i = 0;
+ TC_PRT("BLUETOOTH_EVENT_BONDED_DEVICE_FOUND, result [0x%04x]", param->result);
+ if (param->result >= BLUETOOTH_ERROR_NONE) {
+ ///tc_result(TC_PASS, 15);
+ bluetooth_device_info_t * bt_dev_info = (bluetooth_device_info_t*)param->param_data;
+ TC_PRT("Dev Name = %s, Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X, COD (major,minor,service)= 0x%x:%x:%x\n", bt_dev_info->device_name.name,
+ bt_dev_info->device_address.addr[0], bt_dev_info->device_address.addr[1], bt_dev_info->device_address.addr[2], \
+ bt_dev_info->device_address.addr[3], bt_dev_info->device_address.addr[4], bt_dev_info->device_address.addr[5], \
+ bt_dev_info->device_class.major_class, bt_dev_info->device_class.minor_class, bt_dev_info->device_class.service_class);
- break;
+ } else if (param->result == BLUETOOTH_ERROR_END_OF_DEVICE_LIST) /*End of the Device found indication*/ {
+ tc_result(TC_PASS, 15);
+ TC_PRT("*****<<No more BLUETOOTH_EVENT_BONDED_DEVICE_FOUND indication>>***** ");
+ } else {
+ tc_result(TC_FAIL, 15);
+ TC_PRT("*****API failed ***** ");
}
+#endif
+ break;
+ }
- case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
- {
- bluetooth_device_info_t *device_info = NULL;
- TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
- device_info = (bluetooth_device_info_t *)param->param_data;
- memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
- TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
- device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
- device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
- break;
- }
+ case BLUETOOTH_EVENT_SERVICE_SEARCHED:
+ {
+ int i = 0;
+ TC_PRT("BLUETOOTH_EVENT_SERVICE_SEARCHED, result [0x%04x]", param->result);
+ if (param->result >= BLUETOOTH_ERROR_NONE) {
+ tc_result(TC_PASS, 18);
+ bt_sdp_info_t *bt_sdp_info = param->param_data;
- case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
- TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
- break;
+ TC_PRT("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
+ bt_sdp_info->device_addr.addr[0], bt_sdp_info->device_addr.addr[1], bt_sdp_info->device_addr.addr[2], \
+ bt_sdp_info->device_addr.addr[3], bt_sdp_info->device_addr.addr[4], bt_sdp_info->device_addr.addr[5]);
- case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
- {
- int *mode = (int *)param->param_data;
- TC_PRT("BT_DISCOVERABLE_MODE_CHANGED, result [0x%04x]", param->result);
- TC_PRT("mode [%d]", *mode);
- break;
- }
- case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
- {
- int *timeout = (int *)param->param_data;
- TC_PRT("BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED, result [0x%04x]", param->result);
- TC_PRT("timeout [%d]", *timeout);
- break;
- }
- case BLUETOOTH_EVENT_BONDING_FINISHED:
- {
- TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
- if (param->result >= BLUETOOTH_ERROR_NONE) {
- bluetooth_device_info_t *device_info = NULL;
- tc_result(TC_PASS, 12);
- device_info = (bluetooth_device_info_t *)param->param_data;
- if (device_info == NULL)
- break;
-
- TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X] mjr[%#x] min[%#x] srv[%#x]", device_info->device_name.name, \
- device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
- device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5], \
- device_info->device_class.major_class, device_info->device_class.minor_class, device_info->device_class.service_class);
- } else {
- tc_result(TC_FAIL, 12);
- }
- break;
+ TC_PRT("Supported service list:\n");
+ for (i = 0; i < bt_sdp_info->service_index; i++)
+ TC_PRT("[%#x]\n", bt_sdp_info->service_list_array[i]);
+
+ } else {
+ tc_result(TC_FAIL, 18);
}
+ break;
+ }
- case BLUETOOTH_EVENT_BONDED_DEVICE_FOUND:
- {
- // bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
- // 2011.01.06
-#if 0
-// int i = 0;
- TC_PRT("BLUETOOTH_EVENT_BONDED_DEVICE_FOUND, result [0x%04x]", param->result);
- if (param->result >= BLUETOOTH_ERROR_NONE) {
- ///tc_result(TC_PASS, 15);
- bluetooth_device_info_t * bt_dev_info = (bluetooth_device_info_t*)param->param_data;
+ case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED, result [0x%04x]", param->result);
+ bluetooth_rfcomm_received_data_t *rx_data = param->param_data;
+ printf("\n FD = %d \nBuffer len = %d ", rx_data->socket_fd, rx_data->buffer_size);
+ if (rx_data->buffer_size < sizeof(oob_data_t))
+ TC_PRT("Complete oob data is not recivedn");
+ else
+ memcpy(&g_remote_oob_data, rx_data->buffer, sizeof(oob_data_t));
+ //tc_result(TC_PASS, 21);
+ break;
+ }
- TC_PRT("Dev Name = %s, Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X, COD (major,minor,service)= 0x%x:%x:%x\n", bt_dev_info->device_name.name,
- bt_dev_info->device_address.addr[0], bt_dev_info->device_address.addr[1], bt_dev_info->device_address.addr[2], \
- bt_dev_info->device_address.addr[3], bt_dev_info->device_address.addr[4], bt_dev_info->device_address.addr[5], \
- bt_dev_info->device_class.major_class, bt_dev_info->device_class.minor_class, bt_dev_info->device_class.service_class);
-
- } else if (param->result == BLUETOOTH_ERROR_END_OF_DEVICE_LIST) /*End of the Device found indication*/ {
- tc_result(TC_PASS, 15);
- TC_PRT("*****<<No more BLUETOOTH_EVENT_BONDED_DEVICE_FOUND indication>>***** ");
- } else {
- tc_result(TC_FAIL, 15);
- TC_PRT("*****API failed ***** ");
- }
- break;
-#endif
- }
- case BLUETOOTH_EVENT_SERVICE_SEARCHED:
- {
- int i = 0;
- TC_PRT("BLUETOOTH_EVENT_SERVICE_SEARCHED, result [0x%04x]", param->result);
- if (param->result >= BLUETOOTH_ERROR_NONE) {
- tc_result(TC_PASS, 18);
- bt_sdp_info_t *bt_sdp_info = param->param_data;
-
- TC_PRT("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
- bt_sdp_info->device_addr.addr[0], bt_sdp_info->device_addr.addr[1], bt_sdp_info->device_addr.addr[2], \
- bt_sdp_info->device_addr.addr[3], bt_sdp_info->device_addr.addr[4], bt_sdp_info->device_addr.addr[5]);
-
- TC_PRT("Supported service list:\n");
- for (i = 0; i < bt_sdp_info->service_index; i++)
- TC_PRT("[%#x]\n", bt_sdp_info->service_list_array[i]);
-
- } else {
- tc_result(TC_FAIL, 18);
- }
- break;
- }
- case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
- {
- TC_PRT("BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED, result [0x%04x]", param->result);
- bluetooth_rfcomm_received_data_t *rx_data = param->param_data;
- printf("\n FD = %d \nBuffer len = %d ", rx_data->socket_fd, rx_data->buffer_size);
- if (rx_data->buffer_size < sizeof(oob_data_t))
- TC_PRT("Complete oob data is not recivedn");
- else
- memcpy(&g_remote_oob_data, rx_data->buffer, sizeof(oob_data_t));
- //tc_result(TC_PASS, 21);
- break;
- }
- case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
- {
- bluetooth_rfcomm_connection_t *con_ind = (bluetooth_rfcomm_connection_t *)param->param_data;
- TC_PRT("BLUETOOTH_EVENT_RFCOMM_CONNECTED, result [0x%04x], fd = %d, device add = 0x%X:%X:%X:%X:%X:%X, Role = %s", param->result,
- con_ind->socket_fd,
- con_ind->device_addr.addr[0], con_ind->device_addr.addr[1], con_ind->device_addr.addr[2],
- con_ind->device_addr.addr[3], con_ind->device_addr.addr[4], con_ind->device_addr.addr[5],
- (con_ind->device_role == RFCOMM_ROLE_SERVER) ? "SERVER" : "CLIENT");
- //tc_result(TC_PASS, 22);
- if ((con_ind->device_role == RFCOMM_ROLE_CLIENT) && (con_ind->socket_fd > 0))
- g_ret_client_fd1 = con_ind->socket_fd;
-
- if ((con_ind->device_role == RFCOMM_ROLE_SERVER) && (con_ind->socket_fd > 0))
- client_fd = con_ind->socket_fd;
+ case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
+ {
+ bluetooth_rfcomm_connection_t *con_ind = (bluetooth_rfcomm_connection_t *)param->param_data;
+ TC_PRT("BLUETOOTH_EVENT_RFCOMM_CONNECTED, result [0x%04x], fd = %d, device add = 0x%X:%X:%X:%X:%X:%X, Role = %s", param->result,
+ con_ind->socket_fd,
+ con_ind->device_addr.addr[0], con_ind->device_addr.addr[1], con_ind->device_addr.addr[2],
+ con_ind->device_addr.addr[3], con_ind->device_addr.addr[4], con_ind->device_addr.addr[5],
+ (con_ind->device_role == RFCOMM_ROLE_SERVER) ? "SERVER" : "CLIENT");
+ //tc_result(TC_PASS, 22);
+ if ((con_ind->device_role == RFCOMM_ROLE_CLIENT) && (con_ind->socket_fd > 0))
+ g_ret_client_fd1 = con_ind->socket_fd;
+
+ if ((con_ind->device_role == RFCOMM_ROLE_SERVER) && (con_ind->socket_fd > 0))
+ client_fd = con_ind->socket_fd;
+
+ break;
+ }
- break;
- }
- case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
- {
- bluetooth_rfcomm_disconnection_t *disconnection_ind = (bluetooth_rfcomm_disconnection_t *)param->param_data;;
- TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x] Fd = %d, device add = 0x%X:%X:%X:%X:%X:%X\n", param->result, disconnection_ind->socket_fd,
- disconnection_ind->device_addr.addr[0], disconnection_ind->device_addr.addr[1], disconnection_ind->device_addr.addr[2],
- disconnection_ind->device_addr.addr[3], disconnection_ind->device_addr.addr[4], disconnection_ind->device_addr.addr[5]);
- //tc_result(TC_PASS, 22);
- break;
- }
- case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
- {
- bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
+ case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
+ {
+ bluetooth_rfcomm_disconnection_t *disconnection_ind = (bluetooth_rfcomm_disconnection_t *)param->param_data;;
+ TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x] Fd = %d, device add = 0x%X:%X:%X:%X:%X:%X\n", param->result, disconnection_ind->socket_fd,
+ disconnection_ind->device_addr.addr[0], disconnection_ind->device_addr.addr[1], disconnection_ind->device_addr.addr[2],
+ disconnection_ind->device_addr.addr[3], disconnection_ind->device_addr.addr[4], disconnection_ind->device_addr.addr[5]);
+ //tc_result(TC_PASS, 22);
+ break;
+ }
- TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
- TC_PRT("interface name: %s", dev_info->interface_name);
+ case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
+ {
+ bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
- TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
- dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
- dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
- break;
- }
- case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
- {
- bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
+ TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
+ TC_PRT("interface name: %s", dev_info->interface_name);
- TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
- TC_PRT("interface name: %s", dev_info->interface_name);
+ TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
+ dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
+ dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
+ break;
+ }
- TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
- dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
- dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
- break;
- }
+ case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
+ {
+ bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
- case BLUETOOTH_EVENT_HDP_CONNECTED:
- {
- bt_hdp_connected_t *conn_ind = (bt_hdp_connected_t *)param->param_data;
+ TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
+ TC_PRT("interface name: %s", dev_info->interface_name);
- TC_PRT("BLUETOOTH_EVENT_HDP_CONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
- TC_PRT("App handler = %s, channel id = %d, type = %s", conn_ind->app_handle, conn_ind->channel_id, (conn_ind->type == HDP_QOS_RELIABLE) ? "Reliable" : "Streaming");
- TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
- conn_ind->device_address.addr[0], conn_ind->device_address.addr[1], conn_ind->device_address.addr[2],
- conn_ind->device_address.addr[3], conn_ind->device_address.addr[4], conn_ind->device_address.addr[5]);
+ TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
+ dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
+ dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
+ break;
+ }
- g_ret_client_fd1 = conn_ind->channel_id;
- break;
- }
+ case BLUETOOTH_EVENT_HDP_CONNECTED:
+ {
+ bt_hdp_connected_t *conn_ind = (bt_hdp_connected_t *)param->param_data;
- case BLUETOOTH_EVENT_HDP_DISCONNECTED:
- {
- bt_hdp_disconnected_t *dis_ind = (bt_hdp_disconnected_t *)param->param_data;
+ TC_PRT("BLUETOOTH_EVENT_HDP_CONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
+ TC_PRT("App handler = %s, channel id = %d, type = %s", conn_ind->app_handle, conn_ind->channel_id, (conn_ind->type == HDP_QOS_RELIABLE) ? "Reliable" : "Streaming");
+ TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
+ conn_ind->device_address.addr[0], conn_ind->device_address.addr[1], conn_ind->device_address.addr[2],
+ conn_ind->device_address.addr[3], conn_ind->device_address.addr[4], conn_ind->device_address.addr[5]);
- TC_PRT("BLUETOOTH_EVENT_HDP_DISCONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
- TC_PRT("Channel = %d, Add = device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", dis_ind->channel_id,
- dis_ind->device_address.addr[0], dis_ind->device_address.addr[1], dis_ind->device_address.addr[2],
- dis_ind->device_address.addr[3], dis_ind->device_address.addr[4], dis_ind->device_address.addr[5]);
- break;
- }
+ g_ret_client_fd1 = conn_ind->channel_id;
+ break;
+ }
- case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
- {
- bt_hdp_data_ind_t *data_ind = (bt_hdp_data_ind_t *)param->param_data;
+ case BLUETOOTH_EVENT_HDP_DISCONNECTED:
+ {
+ bt_hdp_disconnected_t *dis_ind = (bt_hdp_disconnected_t *)param->param_data;
- TC_PRT("BLUETOOTH_EVENT_HDP_DATA_RECEIVED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
- TC_PRT("Data received from channel id = %d and size =%d, buff =[%s]\n", data_ind->channel_id, data_ind->size, data_ind->buffer);
+ TC_PRT("BLUETOOTH_EVENT_HDP_DISCONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
+ TC_PRT("Channel = %d, Add = device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", dis_ind->channel_id,
+ dis_ind->device_address.addr[0], dis_ind->device_address.addr[1], dis_ind->device_address.addr[2],
+ dis_ind->device_address.addr[3], dis_ind->device_address.addr[4], dis_ind->device_address.addr[5]);
+ break;
+ }
- break;
- }
+ case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
+ {
+ bt_hdp_data_ind_t *data_ind = (bt_hdp_data_ind_t *)param->param_data;
- case BLUETOOTH_EVENT_OPC_CONNECTED:
- TC_PRT("BLUETOOTH_EVENT_OPC_CONNECTED");
- break;
+ TC_PRT("BLUETOOTH_EVENT_HDP_DATA_RECEIVED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
+ TC_PRT("Data received from channel id = %d and size =%d, buff =[%s]\n", data_ind->channel_id, data_ind->size, data_ind->buffer);
- case BLUETOOTH_EVENT_OPC_DISCONNECTED:
- TC_PRT("BLUETOOTH_EVENT_OPC_DISCONNECTED");
- break;
- case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
- {
- TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
- if (param->param_data) {
- bt_opc_transfer_info_t *info = param->param_data;
- TC_PRT("file %s", info->filename);
- TC_PRT("size %ld", info->size);
- }
- break;
- }
- case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
- {
- TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS");
- break;
- }
- case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
- {
- TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
+ break;
+ }
+
+ case BLUETOOTH_EVENT_OPC_CONNECTED:
+ TC_PRT("BLUETOOTH_EVENT_OPC_CONNECTED");
+ break;
+
+ case BLUETOOTH_EVENT_OPC_DISCONNECTED:
+ TC_PRT("BLUETOOTH_EVENT_OPC_DISCONNECTED");
+ break;
+ case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
+ if (param->param_data) {
bt_opc_transfer_info_t *info = param->param_data;
TC_PRT("file %s", info->filename);
TC_PRT("size %ld", info->size);
- break;
}
+ break;
+ }
+ case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
+ {
+ TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS");
+ break;
+ }
+ case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
+ {
+ TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
+ bt_opc_transfer_info_t *info = param->param_data;
+ TC_PRT("file %s", info->filename);
+ TC_PRT("size %ld", info->size);
+ break;
+ }
- case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
- TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE");
- break;
-
- case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
- TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE");
- break;
-
- case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
- TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED");
- bt_obex_server_transfer_info_t *info = param->param_data;
- current_transfer_id = info->transfer_id;
- break;
-
- case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
- TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS");
- break;
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
+ TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE");
+ break;
+
+ case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
+ TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE");
+ break;
+
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
+ TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED");
+ bt_obex_server_transfer_info_t *info = param->param_data;
+ current_transfer_id = info->transfer_id;
+ break;
+
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
+ TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS");
+ break;
+
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
+ TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED");
+ break;
+ case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
+ { TC_PRT("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
+ break;
+ }
+#if 0
+ case BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED");
+ bt_gatt_handle_info_t *prim_svc = param->param_data;
+ int i;
- case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
- TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED");
- break;
- case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
- { TC_PRT("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
+ if (prim_svc == NULL) {
+ TC_PRT("prim_svc is NULL");
break;
}
-#if 0
- case BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED");
- bt_gatt_handle_info_t *prim_svc = param->param_data;
- int i;
- if (prim_svc == NULL) {
- TC_PRT("prim_svc is NULL");
- break;
- }
+ for (i = 0; i < prim_svc->count; i++)
+ TC_PRT("prim_svc[%d] = %s\n", i, prim_svc->handle[i]);
- for (i = 0; i < prim_svc->count; i++) {
- TC_PRT("prim_svc[%d] = %s\n", i, prim_svc->handle[i]);
- }
+ break;
+ }
+ case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
+ bt_gatt_discovered_char_t *svc_char = param->param_data;
+ int i = 0;
+
+ if (svc_char == NULL) {
+ TC_PRT("svc_char is NULL");
break;
}
- case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
- bt_gatt_discovered_char_t *svc_char = param->param_data;
- int i = 0;
+ if (svc_char->service_handle != NULL)
+ TC_PRT("svc_char->service_handle %s \n", svc_char->service_handle);
- if (svc_char == NULL) {
- TC_PRT("svc_char is NULL");
- break;
- }
+ for (i = 0; i < svc_char->handle_info.count; i++)
+ TC_PRT("svc_char.handle_info.handle[%d] = %s\n", i, svc_char->handle_info.handle[i]);
- if (svc_char->service_handle != NULL) {
- TC_PRT("svc_char->service_handle %s \n", svc_char->service_handle);
- }
+ break;
+ }
- for (i = 0; i < svc_char->handle_info.count; i++) {
- TC_PRT("svc_char.handle_info.handle[%d] = %s\n", i, svc_char->handle_info.handle[i]);
- }
+ case BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED");
+ bt_gatt_service_property_t *svc_pty = param->param_data;
+ int i;
+ if (svc_pty == NULL) {
+ TC_PRT("char_pty is NULL \n");
break;
}
- case BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED");
- bt_gatt_service_property_t *svc_pty = param->param_data;
- int i;
-
- if (svc_pty == NULL) {
- TC_PRT("char_pty is NULL \n");
- break;
- }
-
- if (svc_pty->service_handle != NULL) {
- TC_PRT("svc_pty->service_handle %s \n", svc_pty->service_handle);
- }
-
- if (svc_pty->uuid != NULL) {
- TC_PRT("svc_pty->uuid %s \n", svc_pty->uuid);
- }
+ if (svc_pty->service_handle != NULL)
+ TC_PRT("svc_pty->service_handle %s \n", svc_pty->service_handle);
- for (i = 0; i < svc_pty->handle_info.count; i++) {
- TC_PRT("svc_char[%d] = %s\n", i, svc_pty->handle_info.handle[i]);
- }
+ if (svc_pty->uuid != NULL)
+ TC_PRT("svc_pty->uuid %s \n", svc_pty->uuid);
- break;
- }
+ for (i = 0; i < svc_pty->handle_info.count; i++)
+ TC_PRT("svc_char[%d] = %s\n", i, svc_pty->handle_info.handle[i]);
- case BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED");
- bt_gatt_char_property_t *char_pty = param->param_data;
- int i = 0;
+ break;
+ }
- if (char_pty->char_handle != NULL) {
- TC_PRT("char_pty->char_handle %s \n", char_pty->char_handle);
- }
+ case BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED:
+ {
+ TC_PRT("BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED");
+ bt_gatt_char_property_t *char_pty = param->param_data;
+ int i = 0;
- if (char_pty->uuid != NULL) {
- TC_PRT("char_pty->uuid %s \n", char_pty->uuid);
- }
+ if (char_pty->char_handle != NULL)
+ TC_PRT("char_pty->char_handle %s \n", char_pty->char_handle);
- if (char_pty == NULL) {
- TC_PRT("char_pty is NULL \n");
- break;
- }
+ if (char_pty->uuid != NULL)
+ TC_PRT("char_pty->uuid %s \n", char_pty->uuid);
- if (char_pty->name != NULL) {
- TC_PRT("char_pty->name %s \n", char_pty->name);
- }
+ if (char_pty == NULL) {
+ TC_PRT("char_pty is NULL \n");
+ break;
+ }
- if (char_pty->description != NULL) {
- TC_PRT("char_pty->description %s \n", char_pty->description);
- }
+ if (char_pty->name != NULL)
+ TC_PRT("char_pty->name %s \n", char_pty->name);
- if (char_pty->val != NULL) {
- TC_PRT("char_pty->val_len %d \n", char_pty->val_len);
+ if (char_pty->description != NULL)
+ TC_PRT("char_pty->description %s \n", char_pty->description);
- for (i = 0; i < char_pty->val_len; i++)
- TC_PRT("char_pty->val %02x \n", char_pty->val[i]);
- }
+ if (char_pty->val != NULL) {
+ TC_PRT("char_pty->val_len %d \n", char_pty->val_len);
- break;
+ for (i = 0; i < char_pty->val_len; i++)
+ TC_PRT("char_pty->val %02x \n", char_pty->val[i]);
}
+
+ break;
+ }
#endif
- case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
- {
- bluetooth_authentication_request_info_t *auth_info = param->param_data;
-
- TC_PRT("BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
- TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
- auth_info->device_address.addr[0], auth_info->device_address.addr[1],
- auth_info->device_address.addr[2], auth_info->device_address.addr[3],
- auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
- TC_PRT("Device Name : [%s]", auth_info->device_name.name);
- TC_PRT("Passkey: [%s]", auth_info->str_passkey);
- break;
- }
- case BLUETOOTH_EVENT_PIN_REQUEST:
- {
- bluetooth_authentication_request_info_t *auth_info = param->param_data;
-
- TC_PRT("BLUETOOTH_EVENT_PIN_REQUEST");
- TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
- auth_info->device_address.addr[0], auth_info->device_address.addr[1],
- auth_info->device_address.addr[2], auth_info->device_address.addr[3],
- auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
- TC_PRT("Device Name : [%s]", auth_info->device_name.name);
-
- TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
- bluetooth_passkey_reply("0000", TRUE);
- break;
- }
- case BLUETOOTH_EVENT_PASSKEY_REQUEST:
- {
- bluetooth_authentication_request_info_t *auth_info = param->param_data;
-
- TC_PRT("BLUETOOTH_EVENT_PASSKEY_REQUEST");
- TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
- auth_info->device_address.addr[0], auth_info->device_address.addr[1],
- auth_info->device_address.addr[2], auth_info->device_address.addr[3],
- auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
- TC_PRT("Device Name : [%s]", auth_info->device_name.name);
-
- TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
- bluetooth_passkey_reply("0000", TRUE);
- break;
- }
- case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
- {
- bluetooth_authentication_request_info_t *auth_info = param->param_data;
-
- TC_PRT("BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
- TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
- auth_info->device_address.addr[0], auth_info->device_address.addr[1],
- auth_info->device_address.addr[2], auth_info->device_address.addr[3],
- auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
- TC_PRT("Device Name : [%s]", auth_info->device_name.name);
- TC_PRT("Passkey: [%s]", auth_info->str_passkey);
-
- TC_PRT("bluetooth_passkey_confirmation_reply: TRUE");
- bluetooth_passkey_confirmation_reply(TRUE);
- break;
- }
- default:
- TC_PRT("received event [0x%04x]", event);
- break;
+ case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
+ {
+ bluetooth_authentication_request_info_t *auth_info = param->param_data;
+
+ TC_PRT("BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
+ TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
+ auth_info->device_address.addr[0], auth_info->device_address.addr[1],
+ auth_info->device_address.addr[2], auth_info->device_address.addr[3],
+ auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
+ TC_PRT("Device Name : [%s]", auth_info->device_name.name);
+ TC_PRT("Passkey: [%s]", auth_info->str_passkey);
+ break;
+ }
+ case BLUETOOTH_EVENT_PIN_REQUEST:
+ {
+ bluetooth_authentication_request_info_t *auth_info = param->param_data;
+
+ TC_PRT("BLUETOOTH_EVENT_PIN_REQUEST");
+ TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
+ auth_info->device_address.addr[0], auth_info->device_address.addr[1],
+ auth_info->device_address.addr[2], auth_info->device_address.addr[3],
+ auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
+ TC_PRT("Device Name : [%s]", auth_info->device_name.name);
+
+ TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
+ bluetooth_passkey_reply("0000", TRUE);
+ break;
+ }
+ case BLUETOOTH_EVENT_PASSKEY_REQUEST:
+ {
+ bluetooth_authentication_request_info_t *auth_info = param->param_data;
+
+ TC_PRT("BLUETOOTH_EVENT_PASSKEY_REQUEST");
+ TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
+ auth_info->device_address.addr[0], auth_info->device_address.addr[1],
+ auth_info->device_address.addr[2], auth_info->device_address.addr[3],
+ auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
+ TC_PRT("Device Name : [%s]", auth_info->device_name.name);
+
+ TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
+ bluetooth_passkey_reply("0000", TRUE);
+ break;
+ }
+ case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
+ {
+ bluetooth_authentication_request_info_t *auth_info = param->param_data;
+
+ TC_PRT("BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
+ TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
+ auth_info->device_address.addr[0], auth_info->device_address.addr[1],
+ auth_info->device_address.addr[2], auth_info->device_address.addr[3],
+ auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
+ TC_PRT("Device Name : [%s]", auth_info->device_name.name);
+ TC_PRT("Passkey: [%s]", auth_info->str_passkey);
+
+ TC_PRT("bluetooth_passkey_confirmation_reply: TRUE");
+ bluetooth_passkey_confirmation_reply(TRUE);
+ break;
+ }
+ default:
+ TC_PRT("received event [0x%04x]", event);
+ break;
}
TC_PRT("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
}
unsigned int len = 0;
int test_id;
- if (g_io_channel_read_chars(chan, buf, sizeof(buf),
+ if (g_io_channel_read_chars(chan, buf, sizeof(buf),
&len, NULL) == G_IO_STATUS_ERROR) {
printf("IO Channel read error");
return FALSE;
+++ /dev/null
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(bluetooth-hf-test C)
-
-SET(SRCS bluetooth-hf-test.c)
-
-SET(PREFIX ${CMAKE_INSTALL_PREFIX})
-
-INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/bt-api/)
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(package REQUIRED dlog dbus-1 glib-2.0 gthread-2.0 gobject-2.0)
-
-FOREACH(flag ${package_CFLAGS})
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
-
-FIND_PROGRAM(UNAME NAMES uname)
-EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
-IF("${ARCH}" STREQUAL "arm")
- ADD_DEFINITIONS("-DTARGET")
- MESSAGE("add -DTARGET")
-ENDIF("${ARCH}" STREQUAL "arm")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DFACTORYFS=\"$ENV{FACTORYFS}\"")
-
-ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
-TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${package_LDFLAGS} -L${CMAKE_SOURCE_DIR}/bt-api/ -lbluetooth-api)
-
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-/**
- * @file bluetooth-telephony-test.c
- * @brief This is the source file for bluetooth telephony test suite.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <glib.h>
-#include <dbus/dbus-glib.h>
-#include <pthread.h>
-
-#include "bluetooth-audio-api.h"
-#include "bluetooth-api.h"
-
-#define PRT(format, args...) printf("%s:%d() "format, \
- __FUNCTION__, __LINE__, ##args)
-#define TC_PRT(format, args...) PRT(format"\n", ##args)
-
-GMainLoop *main_loop = NULL;
-static int timeout_status = 0;
-#define DEFAULT_CALL_ID 1
-/*Change this number with Testing SIM*/
-#define TEST_NUMBER "9980785507"
-#define BLUETOOTH_HF_SPEAKER_GAIN 2
-
-typedef struct {
- const char *tc_name;
- int tc_code;
-} tc_table_t;
-
-tc_table_t tc_table[] = {
- /*HF Application*/
- {"bluetooth_hf_init", 1},
- {"bluetooth_hf_deinit", 2},
- {"Answer Call", 3},
- {"Terminate Call", 4},
- {"Initiate Call", 5},
- {"Last number Redial ", 6},
- {"(PTS) Connect last bonded device", 7},
- {"Disconnect", 8},
- {"(PTS) Voice Recognition Enable", 9},
- {"Voice RecognitionDisable", 10},
- {"SCO disconnect", 11},
- {"Speaker gain", 12},
- {"Dual Tone mulitple frequency", 13},
- {"Send AT+XSAT=appid command", 14},
- {"Release All Call(CHLD=0)", 15},
- {"Release and Accept(CHLD=1)", 16},
- {"Swap call (CHLD=2)", 17},
- {"Join Call (CHLD=3)", 18},
- {"(PTS) Initiate Codec based SCO", 19},
- {"(PTS) Unbond all devices", 20},
- {"Get Current Codec", 21},
- {"Get Call List", 22},
- {"Get Audio Connected Status", 23},
- {"Is Handsfree Connected?", 24},
-
- /* -----------------------------------------*/
- {"Finish", 0x00ff},
- {NULL, 0x0000},
-
-};
-
-#define tc_result(success, tc_index) \
- TC_PRT("Test case [%d - %s] %s", tc_table[tc_index].tc_code, \
- tc_table[tc_index].tc_name, \
- ((success == TC_PASS) ? "Success" : "Failed"));
-
-void tc_usage_print(void)
-{
- int i = 0;
-
- while (tc_table[i].tc_name) {
- if (tc_table[i].tc_code != 0x00ff) {
- TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
- tc_table[i].tc_name);
- } else {
- TC_PRT("Key %d : usage %s\n\n", 0x00ff,
- tc_table[i].tc_name);
- }
-
- i++;
- }
-}
-void bt_event_callback(int event, bluetooth_event_param_t *param, void *user_data)
-{
-
-}
-
-void hf_event_handler(int event, void *data, void *user_data)
-{
- bt_hf_event_param_t *hf_event;
-
- if (data == NULL)
- return;
- hf_event = data;
-
- TC_PRT("HF event : [0x%04x]", event);
-
- switch (event) {
- case BLUETOOTH_EVENT_HF_CONNECTED:
- TC_PRT("BLUETOOTH_EVENT_HF_CONNECTED");
- break;
-
- case BLUETOOTH_EVENT_HF_DISCONNECTED:
- TC_PRT("BLUETOOTH_EVENT_HF_DISCONNECTED");
- break;
-
- case BLUETOOTH_EVENT_HF_AUDIO_CONNECTED:
- TC_PRT("BLUETOOTH_EVENT_HF_AUDIO_CONNECTED");
- break;
-
- case BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED:
- TC_PRT("BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED");
- break;
-
- case BLUETOOTH_EVENT_HF_RING_INDICATOR:
- TC_PRT("BLUETOOTH_EVENT_HF_RING_INDICATOR");
- if (hf_event->param_data)
- TC_PRT("Phone number %s", hf_event->param_data);
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_WAITING:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_WAITING");
- if (hf_event->param_data)
- TC_PRT("Waiting Phone number %s", hf_event->param_data);
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_TERMINATED:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_TERMINATED");
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_STARTED:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_STARTED");
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_ENDED:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_ENDED");
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_UNHOLD:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_UNHOLD");
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_SWAPPED:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_SWAPPED");
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_ON_HOLD:
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_ON_HOLD");
- break;
-
- case BLUETOOTH_EVENT_HF_CALL_STATUS:
- {
- TC_PRT("BLUETOOTH_EVENT_HF_CALL_STATUS");
- int i;
- bt_hf_call_list_s * call_list = hf_event->param_data;
- bt_hf_call_status_info_t **call_info;
- TC_PRT("call_list length : %d ", call_list->count);
- call_info = g_malloc0(sizeof(bt_hf_call_status_info_t *) *
- call_list->count);
- bluetooth_hf_get_call_list(call_list->list, call_info);
-
- for (i = 0; i < call_list->count; i++) {
- TC_PRT("Phone Number : %s ", call_info[i]->number);
- TC_PRT("Direction (in -1, out 0 : %d ", call_info[i]->direction);
- TC_PRT("Call status : %d ", call_info[i]->status);
- TC_PRT("MultyParty : %d ", call_info[i]->mpart);
- TC_PRT("Call ID : %d ", call_info[i]->idx);
- }
- g_free(call_info);
- break;
- }
- case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED:
- TC_PRT("BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED");
- break;
-
- case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED:
- TC_PRT("BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED");
- break;
-
- case BLUETOOTH_EVENT_HF_VOLUME_SPEAKER:
- {
- unsigned int *value;
- value = hf_event->param_data;
- TC_PRT("BLUETOOTH_EVENT_HF_VOLUME_SPEAKER - value = %d", *value);
- break;
- }
- case BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD:
- {
- bluetooth_vendor_dep_at_cmd_t *cmd = hf_event->param_data;
- TC_PRT("BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD - appid = %d, msg = %s",
- cmd->app_id, cmd->message);
- break;
- }
-
- default:
- break;
- }
-}
-
-static int __bt_unbond_all_bonded_devices(void)
-{
- int ret;
- int i;
- bluetooth_device_info_t *ptr;
-
- GPtrArray *dev_list = NULL;
- dev_list = g_ptr_array_new();
- TC_PRT("g pointer arrary count : [%d]", dev_list->len);
-
- ret = bluetooth_get_bonded_device_list(&dev_list);
- if (ret < 0) {
- TC_PRT("failed bluetooth_get_bonded_device_list");
- g_ptr_array_free(dev_list, TRUE);
- return 1;
- }
- TC_PRT("g pointer arrary count : [%d]", dev_list->len);
-
- if (dev_list->len == 0) {
- TC_PRT("No paired device found");
- g_ptr_array_free(dev_list, TRUE);
- return 1;
- }
-
- for (i = 0; i < dev_list->len; i++) {
- ptr = g_ptr_array_index(dev_list, i);
- if (ptr == NULL)
- continue;
- TC_PRT("[%d] Unbond %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", i + 1,
- ptr->device_address.addr[0], ptr->device_address.addr[1],
- ptr->device_address.addr[2], ptr->device_address.addr[3],
- ptr->device_address.addr[4], ptr->device_address.addr[5]);
- bluetooth_unbond_device(&ptr->device_address);
-
- }
- g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL);
- g_ptr_array_free(dev_list, TRUE);
- return 0;
-
-}
-static int __bt_get_last_bonded_device(bluetooth_device_address_t *device_address)
-{
- int ret;
- int i;
- bluetooth_device_info_t *ptr;
-
- GPtrArray *dev_list = NULL;
- dev_list = g_ptr_array_new();
- TC_PRT("g pointer arrary count : [%d]", dev_list->len);
-
- ret = bluetooth_get_bonded_device_list(&dev_list);
- if (ret < 0) {
- TC_PRT("failed bluetooth_get_bonded_device_list");
- g_ptr_array_free(dev_list, TRUE);
- return 1;
- }
- TC_PRT("g pointer arrary count : [%d]", dev_list->len);
-
- if (dev_list->len == 0) {
- TC_PRT("No paired device found");
- g_ptr_array_free(dev_list, TRUE);
- return 1;
- }
-
- for (i = 0; i < dev_list->len; i++) {
- ptr = g_ptr_array_index(dev_list, i);
- if (ptr == NULL)
- continue;
- TC_PRT("[%d] %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", i + 1,
- ptr->device_address.addr[0], ptr->device_address.addr[1],
- ptr->device_address.addr[2], ptr->device_address.addr[3],
- ptr->device_address.addr[4], ptr->device_address.addr[5]);
- memcpy(device_address->addr, ptr->device_address.addr,
- sizeof(bluetooth_device_address_t));
- }
- g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL);
- g_ptr_array_free(dev_list, TRUE);
- return 0;
-
-}
-
-int test_input_callback(void *data)
-{
- int ret;
- int test_id = (int)data;
-
- switch (test_id) {
- case 0x00ff:
- TC_PRT("Finished");
- g_main_loop_quit(main_loop);
- break;
-
- case 1:
- bluetooth_hf_init(hf_event_handler, NULL);
- break;
- case 2:
- bluetooth_hf_deinit();
- break;
- case 3:
- bluetooth_hf_answer_call();
- break;
- case 4:
- bluetooth_hf_terminate_call();
- break;
- case 5:
- ret = bluetooth_hf_initiate_call(TEST_NUMBER);
- TC_PRT("ret = %d", ret);
- break;
- case 6:
- bluetooth_hf_initiate_call(NULL);
- break;
- case 7:
- { bluetooth_device_address_t device_address = { {0} };
- ret = __bt_get_last_bonded_device(&device_address);
- if (ret != 0) {
- TC_PRT("Error in getting last bonded device.....");
- return FALSE;
- }
-
- bluetooth_hf_connect(&device_address);
- break;
- }
- case 8:
- {
- bluetooth_device_address_t device_address = { {0} };
- ret = __bt_get_last_bonded_device(&device_address);
- if (ret != 0) {
- TC_PRT("Error in getting last bonded device.....");
- return FALSE;
- }
-
- bluetooth_hf_disconnect(&device_address);
- break;
- }
- case 9:
- bluetooth_hf_voice_recognition(1);
- break;
-
- case 10:
- bluetooth_hf_voice_recognition(0);
- break;
- case 11:
- bluetooth_hf_audio_disconnect();
- break;
- case 12:
- bluetooth_hf_set_speaker_gain(BLUETOOTH_HF_SPEAKER_GAIN);
- break;
- case 13:
- bluetooth_hf_send_dtmf("1");
- break;
- case 14:
- /* get the Call Time from AG for DC lauch */
- bluetooth_hf_send_xsat_cmd(11, "Q_CT,1,01025561613");
- break;
- case 15:
- bluetooth_hf_release_all_call();
- break;
- case 16:
- bluetooth_hf_release_and_accept();
- break;
- case 17:
- bluetooth_hf_swap_call();
- break;
- case 18:
- bluetooth_hf_join_call();
- break;
- case 19:
- system("dbus-send --system --print-reply --dest=org.bluez.hf_agent /org/bluez/handsfree_agent org.tizen.HfApp.SendAtCmd string:AT+BCC");
- break;
- case 20:
- {
- ret = bluetooth_register_callback(bt_event_callback, NULL);
- ret = __bt_unbond_all_bonded_devices();
- if (ret != 0) {
- TC_PRT("Error in getting last bonded device.....");
- return FALSE;
- }
-
- break;
- }
- case 21:
- {
- unsigned int current_codec;
- bluetooth_hf_get_codec(¤t_codec);
- if (current_codec == BLUETOOTH_CODEC_ID_CVSD)
- TC_PRT("current_codec is CVSD");
- else
- TC_PRT("current_codec is. MSBC");
- break;
- }
- case 22:
- {
- int i;
- bt_hf_call_list_s * call_list = NULL;
- bt_hf_call_status_info_t **call_info = NULL;
- bluetooth_hf_request_call_list(&call_list);
- if (call_list == NULL) {
- TC_PRT("call_list is NULL");
- break;
- }
- TC_PRT("call_list length : %d ", call_list->count);
- call_info = g_malloc0(sizeof(bt_hf_call_status_info_t *) *
- call_list->count);
- bluetooth_hf_get_call_list(call_list->list, call_info);
-
- for (i = 0; i < call_list->count; i++) {
- TC_PRT("Phone Number : %s ", call_info[i]->number);
- TC_PRT("Direction (in -1, out 0 : %d ", call_info[i]->direction);
- TC_PRT("Call status : %d ", call_info[i]->status);
- TC_PRT("MultyParty : %d ", call_info[i]->mpart);
- TC_PRT("Call ID : %d ", call_info[i]->idx);
- }
- g_free(call_info);
- bluetooth_hf_free_call_list(call_list);
- break;
- }
- case 23:
- {
- unsigned int sco_audio_connected;
- bluetooth_hf_get_audio_connected(&sco_audio_connected);
- if (sco_audio_connected == BLUETOOTH_HF_AUDIO_CONNECTED)
- TC_PRT("SCO Audio is connected");
- else
- TC_PRT("SCO Audio is disconnected");
- break;
- }
- case 24:
- {
- gboolean hf_connected;
- bluetooth_hf_is_connected(&hf_connected);
- if (hf_connected == BLUETOOTH_HF_AUDIO_CONNECTED)
- TC_PRT("HF is connected");
- else
- TC_PRT("HF is disconnected");
- break;
- }
- default:
- break;
- }
-
- return 0;
-}
-
-void startup()
-{
- TC_PRT("bluetooth framework TC startup");
-
- dbus_threads_init_default();
-
- main_loop = g_main_loop_new(NULL, FALSE);
-}
-
-void cleanup()
-{
- TC_PRT("bluetooth framework TC cleanup");
- if (main_loop != NULL) {
- g_main_loop_unref(main_loop);
- }
-}
-
-static gboolean key_event_cb(GIOChannel *chan, GIOCondition cond ,
- gpointer data)
-{
- char buf[10] = {0};
-
- unsigned int len = 0;
- int test_id;
- memset(buf, 0, sizeof(buf));
-
- if (g_io_channel_read(chan, buf, sizeof(buf), &len) !=
- G_IO_ERROR_NONE) {
-
- printf("IO Channel read error");
- return FALSE;
-
- }
- printf("%s\n", buf);
- tc_usage_print();
-
- test_id = atoi(buf);
-
- if (test_id)
- g_idle_add(test_input_callback, (void *)test_id);
-
- return TRUE;
-}
-
-int main()
-{
- startup();
-
- GIOChannel *key_io;
- key_io = g_io_channel_unix_new(fileno(stdin));
-
- g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
- key_event_cb, NULL);
- g_io_channel_unref(key_io);
-
-
- g_main_loop_run(main_loop);
-
- cleanup();
- return 0;
-}
unsigned int len = 0;
int test_id;
- if (g_io_channel_read_chars(chan, buf, sizeof(buf),
+ if (g_io_channel_read_chars(chan, buf, sizeof(buf),
&len, NULL) == G_IO_STATUS_ERROR) {
printf("IO Channel read error");
return FALSE;
+++ /dev/null
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(bluetooth-media-control-test C)
-
-SET(SRCS bluetooth-media-control-test.c)
-
-SET(PREFIX ${CMAKE_INSTALL_PREFIX})
-
-INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/bt-api)
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(package REQUIRED dlog dbus-1 glib-2.0 gthread-2.0 gobject-2.0)
-
-FOREACH(flag ${package_CFLAGS})
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
-
-FIND_PROGRAM(UNAME NAMES uname)
-EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
-IF("${ARCH}" STREQUAL "arm")
- ADD_DEFINITIONS("-DTARGET")
- MESSAGE("add -DTARGET")
-ENDIF("${ARCH}" STREQUAL "arm")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DFACTORYFS=\"$ENV{FACTORYFS}\"")
-
-ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
-TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${package_LDFLAGS} -L${CMAKE_SOURCE_DIR}/bt-api -lbluetooth-api)
-
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "bluetooth-media-control.h"
-
-#include <glib.h>
-#include <dbus/dbus-glib.h>
-#include <dbus/dbus-glib-lowlevel.h>
-
-#define MEDIA_ATRRIBUTE_LENGTH 256
-
-media_player_settings_t player_settings = {0x00, 0x00, 0x00, 0x00, 0x01, 1111};
-media_metadata_attributes_t metadata = {"Test Track", "Chethan", "TNC", "Tumkur", 1, 1, 14400};
-
-void static __choose_metadata_settings(void)
-{
- int cmd;
- media_metadata_attributes_t metadata = {0,};
-
- while (1) {
- printf("\nPlease enter\n");
- printf("\t0: return to main menu\n");
- printf("\t1: Meta data settings\n");
- printf("\tEnter your choice [ ]\b\b");
-
- scanf("%d", &cmd);
-
- switch (cmd) {
- case 0:
- return;
- case 1: /* Title */
-
- metadata.title = calloc(1, MEDIA_ATRRIBUTE_LENGTH);
- metadata.artist = calloc(1, MEDIA_ATRRIBUTE_LENGTH);
- metadata.album = calloc(1, MEDIA_ATRRIBUTE_LENGTH);
- metadata.genre = calloc(1, MEDIA_ATRRIBUTE_LENGTH);
-
- printf("Enter the \"Track\" name\n");
- scanf("%s", (char *)metadata.title);
-
- printf(" Enter the \"Artist\" name\n");
- scanf("%s", (char *)metadata.artist);
-
- printf(" Enter the \"Album\" name\n");
- scanf("%s", (char *)metadata.album);
-
- printf(" Enter the \"Genre\" \n");
- scanf("%s", (char *)metadata.genre);
-
- printf(" Enter the \" Totol NumberOfTracks\" \n");
- scanf("%d", &metadata.total_tracks);
-
- printf(" Enter the \" Track Number\" \n");
- scanf("%d", &metadata.number);
-
- printf(" Enter the \"Duration\" \n");
- scanf("%d", &metadata.duration);
- break;
- default:
- break;
- }
- bluetooth_media_player_change_track(&metadata);
-
- if (NULL != metadata.title) {
- free((void *)metadata.title);
- metadata.title = NULL;
- }
- if (NULL != metadata.artist) {
- free((void *)metadata.artist);
- metadata.artist = NULL;
- }
- if (NULL != metadata.album) {
- free((void *)metadata.album);
- metadata.album = NULL;
- }
- if (NULL != metadata.genre) {
- free((void *)metadata.genre);
- metadata.genre = NULL;
- }
- }
-}
-
-void static __choose_player_settings(void)
-{
- int cmd;
- media_player_property_type type;
-
- while (1) {
- printf("\nPlease choose player settings\n");
- printf("\t0: return to main menu\n");
- printf("\t1. Equalizer\n");
- printf("\t2. Repeat\n");
- printf("\t3. Shuffle\n");
- printf("\t4. Scan \n");
- printf("\t5. Status \n");
- printf("\t6. Position \n");
- printf("\tEnter your choice [ ]\b\b");
-
- scanf("%d", &cmd);
-
- switch (cmd) {
- case 0:
- return;
- case 1: /* Equalizer */
- {
- printf("Possible Values - EQUALIZER_OFF = 0x00 and EQUALIZER_ON = 0x01,\n");
- scanf("%d", &player_settings.equalizer);
- type = EQUALIZER;
-
- bluetooth_media_player_change_property(type,
- (unsigned int)player_settings.equalizer);
-
- break;
- }
- case 2: /*Repeat */
- {
- printf(" Possible Values - REPEAT_MODE_OFF = 0x00, REPEAT_SINGLE_TRACK = 0x01 , \
- REPEAT_ALL_TRACK = 0x02, REPEAT_GROUP = 0x03\n");
- scanf("%d", &player_settings.repeat);
- type = REPEAT;
-
- bluetooth_media_player_change_property(type,
- (unsigned int)player_settings.repeat);
- break;
- }
- case 3: /* Shuffle */
- {
- printf(" Possible Values - SHUFFLE_MODE_OFF = 0x00, SHUFFLE_ALL_TRACK = 0x01 , \
- SHUFFLE_GROUP = 0x02\n");
- scanf("%d", &player_settings.shuffle);
- type = SHUFFLE;
-
- bluetooth_media_player_change_property(type,
- (unsigned int)player_settings.shuffle);
- break;
- }
- case 4: /* Scan */
- {
- printf(" Possible Values - SCAN_MODE_OFF = 0x00, SCAN_ALL_TRACK = 0x01 , \
- SCAN_GROUP = 0x02\n");
- scanf("%d", &player_settings.scan);
- type = SCAN;
-
- bluetooth_media_player_change_property(type,
- (unsigned int)player_settings.scan);
- break;
- }
- case 5: /* Status */
- {
- printf(" Possible Values - STATUS_PLAYING = 0x00, STATUS_STOPPED = 0x01 , \
- STATUS_PAUSED = 0x02,STATUS_FORWARD_SEEK = 0x03 \
- STATUS_REVERSE_SEEK = 0x04 STATUS_ERROR = 0x05\n");
- scanf("%d", &player_settings.status);
- type = STATUS;
-
- bluetooth_media_player_change_property(type,
- (unsigned int)player_settings.status);
- break;
- }
- case 6: /* Position */
- {
- printf("Enter the possible value: ");
- scanf("%d", &player_settings.position);
- type = POSITION;
-
- bluetooth_media_player_change_property(type,
- player_settings.position);
- break;
- }
- default:
- break;
- }
- }
-}
-
-int main()
-{
- GMainLoop *agent_loop;
- int cmd;
-
- agent_loop = g_main_loop_new(NULL, FALSE);
-
- printf("MP-AV test application started\n");
- while (1) {
- printf("\n\n\t0. Exit\n");
- printf("\t1. bluetooth_media_player_property_changed\n");
- printf("\t2. bluetooth_media_player_track_changed\n");
- printf("\tEnter your choice [ ]\b\b");
-
- scanf("%d", &cmd);
-
- switch (cmd) {
- case 0: /* exit the application */
- {
- exit(0);
- break;
- }
- case 1:
- {
- __choose_player_settings();
- break;
- }
- case 2:
- {
- __choose_metadata_settings();
- break;
- }
- }
- }
- printf("gmain loop enter\n");
- g_main_loop_run(agent_loop);
- printf("gmain loop leave\n");
- return 0;
-}
+++ /dev/null
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(bluetooth-telephony-test C)
-
-SET(SRCS bluetooth-telephony-test.c)
-
-SET(PREFIX ${CMAKE_INSTALL_PREFIX})
-
-INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/bt-api/)
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(package REQUIRED dlog dbus-glib-1 glib-2.0 gthread-2.0)
-
-FOREACH(flag ${package_CFLAGS})
- SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
-
-FIND_PROGRAM(UNAME NAMES uname)
-EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
-IF("${ARCH}" STREQUAL "arm")
- ADD_DEFINITIONS("-DTARGET")
- MESSAGE("add -DTARGET")
-ENDIF("${ARCH}" STREQUAL "arm")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DFACTORYFS=\"$ENV{FACTORYFS}\"")
-
-ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
-TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${package_LDFLAGS} -L${CMAKE_SOURCE_DIR}/bt-api/ -lbluetooth-api)
-
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-/**
- * @file bluetooth-telephony-test.c
- * @brief This is the source file for bluetooth telephony test suite.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <glib.h>
-#include <dbus/dbus-glib.h>
-#include <pthread.h>
-
-#include "bluetooth-telephony-api.h"
-
-
-#define PRT(format, args...) printf("%s:%d() "format, \
- __FUNCTION__, __LINE__, ##args)
-#define TC_PRT(format, args...) PRT(format"\n", ##args)
-
-GMainLoop *main_loop = NULL;
-static int timeout_status = 0;
-#define DEFAULT_CALL_ID 1
-/*Change this number with Testing SIM*/
-#define TEST_NUMBER "9986008917"
-
-typedef struct {
- const char *tc_name;
- int tc_code;
-} tc_table_t;
-
-tc_table_t tc_table[] = {
- /*Telephony Application*/
- {"bluetooth_telephony_init", 70},
- {"bluetooth_telephony_deinit", 71},
- {"Indicate Outgoing call", 72},
- {"Indicate Incoming call", 73},
- {"Speaker to Headphone", 74},
- {"Headphone to Speaker ", 75},
- {"Call End/Release", 76},
- {"Call Hold", 77},
- {"bluetooth_telephony_call_remote_ringing", 78},
- {"Call Swap", 79},
- {"Call Reject", 80},
- {"Call Answer", 81},
- {"Is SCO channel connected", 82},
- {"Voice Recognition Start", 83},
- {"Voice Recognition Stop", 84},
- {"NREC Status", 85},
- {"WBS Status", 86},
- {"Vendor dep AT CMD [+XSAT: 11,DUAL,DUAL]", 87},
-
- /* -----------------------------------------*/
- {"Finish", 0x00ff},
- {NULL, 0x0000},
-
-};
-
-#define tc_result(success, tc_index) \
- TC_PRT("Test case [%d - %s] %s", tc_table[tc_index].tc_code, \
- tc_table[tc_index].tc_name, \
- ((success == TC_PASS) ? "Success" : "Failed"));
-
-void tc_usage_print(void)
-{
- int i = 0;
-
- while (tc_table[i].tc_name) {
- if (tc_table[i].tc_code != 0x00ff) {
- TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
- tc_table[i].tc_name);
- } else {
- TC_PRT("Key %d : usage %s\n\n", 0x00ff,
- tc_table[i].tc_name);
- }
-
- i++;
- }
-}
-
-void telephony_event_handler(int event, void *data, void *user_data)
-{
- telephony_event_param_t *bt_event;
-
- if (data == NULL)
- return;
- bt_event = data;
-
- TC_PRT("AG event : [0x%04x]", event);
-
- switch (event) {
- case BLUETOOTH_EVENT_TELEPHONY_ANSWER_CALL:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_ANSWER_CALL");
- bluetooth_telephony_call_answered(DEFAULT_CALL_ID, TRUE);
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_RELEASE_CALL:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_RELEASE_CALL");
- bluetooth_telephony_call_end(DEFAULT_CALL_ID);
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_REJECT_CALL:
- bluetooth_telephony_call_end(DEFAULT_CALL_ID);
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_CHLD_0_RELEASE_ALL_HELD_CALL:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_CHLD_0_RELEASE_ALL_HELD_CALL");
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_CHLD_1_RELEASE_ALL_ACTIVE_CALL:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_CHLD_1_RELEASE_ALL_ACTIVE_CALL");
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_CHLD_3_MERGE_CALL:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_CHLD_3_MERGE_CALL");
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_CHLD_2_ACTIVE_HELD_CALL:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_CHLD_2_ACTIVE_HELD_CALL");
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_SEND_DTMF:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_SEND_DTMF");
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_CHLD_4_EXPLICIT_CALL_TRANSFER:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_CHLD_4_EXPLICIT_CALL_TRANSFER");
- break;
-
- case BLUETOOTH_EVENT_TELEPHONY_NREC_CHANGED: {
- gboolean *nrec;
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_NREC_CHANGED");
- nrec = bt_event->param_data;
- TC_PRT("NREC status = [%d]", *nrec);
- break;
- case BLUETOOTH_EVENT_TELEPHONY_VENDOR_AT_CMD:
- TC_PRT("BLUETOOTH_EVENT_TELEPHONY_VENDOR_AT_CMD %s", bt_event->param_data);
- break;
- }
-
- default:
- break;
- }
-}
-
-int test_input_callback(void *data)
-{
- int test_id = (int)data;
-
- switch (test_id) {
- case 0x00ff:
- TC_PRT("Finished");
- g_main_loop_quit(main_loop);
- break;
-
- case 70:
- bluetooth_telephony_init(telephony_event_handler, NULL);
- break;
- case 71:
- bluetooth_telephony_deinit();
- break;
-
- case 72:
- bluetooth_telephony_indicate_outgoing_call(
- TEST_NUMBER, DEFAULT_CALL_ID, TRUE);
- break;
- case 73:
- bluetooth_telephony_indicate_incoming_call(
- TEST_NUMBER, TRUE);
- break;
- case 74:
- bluetooth_telephony_audio_open();
- break;
- case 75:
- bluetooth_telephony_audio_close();
- break;
- case 76:
- bluetooth_telephony_call_end(DEFAULT_CALL_ID);
- break;
- case 77:
- bluetooth_telephony_call_held(DEFAULT_CALL_ID);
- break;
- case 78:
- bluetooth_telephony_call_remote_ringing(
- DEFAULT_CALL_ID);
- break;
- case 79:
- TC_PRT("bluetooth_telephony_call_swapped \n");
- break;
- case 80:
- bluetooth_telephony_call_answered(
- DEFAULT_CALL_ID, FALSE);
- break;
- case 81:
- bluetooth_telephony_call_answered(
- DEFAULT_CALL_ID, TRUE);
- break;
-
- case 82: {
- int state;
-
- state = bluetooth_telephony_is_sco_connected();
-
- TC_PRT("State = %d \n", state);
- break;
- }
-
- case 83: {
- int ret = 0;
-
- TC_PRT("**********************\n");
- TC_PRT(" PLEASE SPEAK \n");
- TC_PRT("**********************\n");
-
- ret = bluetooth_telephony_start_voice_recognition();
-
- if (ret == BLUETOOTH_TELEPHONY_ERROR_NONE) {
- TC_PRT("No error\n");
- bluetooth_telephony_audio_open();
- }
- break;
- }
-
- case 84: {
- TC_PRT("Rcognition finished \n");
- bluetooth_telephony_audio_close();
- bluetooth_telephony_stop_voice_recognition();
- break;
- }
-
- case 85: {
- int ret;
- gboolean status = FALSE;
-
- ret = bluetooth_telephony_is_nrec_enabled(&status);
-
- if (ret != BLUETOOTH_TELEPHONY_ERROR_NONE)
- TC_PRT("Error getting NREC Status\n");
-
- TC_PRT("NREC status = %d\n", status);
- break;
- }
-
- case 86: {
- int ret;
- gboolean status = FALSE;
-
- ret = bluetooth_telephony_is_wbs_mode(&status);
-
- if (ret != BLUETOOTH_TELEPHONY_ERROR_NONE)
- TC_PRT("Error getting WBS Status\n");
-
- TC_PRT("WBS status = %d\n", status);
- break;
- }
- case 87: {
- int ret = 0;
-
- TC_PRT("Vendor dependent AT Command\n");
-
- ret = bluetooth_telephony_send_vendor_cmd("+XSAT: 11,DUAL,DUAL");
-
- if (ret == BLUETOOTH_TELEPHONY_ERROR_NONE) {
- TC_PRT("No error\n");
- }
- break;
- }
- default:
- break;
- }
-
- return 0;
-}
-
-void startup()
-{
- TC_PRT("bluetooth framework TC startup");
-
- dbus_threads_init_default();
-
- main_loop = g_main_loop_new(NULL, FALSE);
-}
-
-void cleanup()
-{
- TC_PRT("bluetooth framework TC cleanup");
- if (main_loop != NULL) {
- g_main_loop_unref(main_loop);
- }
-}
-
-static gboolean key_event_cb(GIOChannel *chan, GIOCondition cond ,
- gpointer data)
-{
- char buf[10] = {0};
-
- unsigned int len = 0;
- int test_id;
- memset(buf, 0, sizeof(buf));
-
- if (g_io_channel_read(chan, buf, sizeof(buf), &len) !=
- G_IO_ERROR_NONE) {
-
- printf("IO Channel read error");
- return FALSE;
-
- }
- printf("%s\n", buf);
- tc_usage_print();
-
- test_id = atoi(buf);
-
- if (test_id)
- g_idle_add(test_input_callback, (void *)test_id);
-
- return TRUE;
-}
-
-int main()
-{
- startup();
-
- GIOChannel *key_io;
- key_io = g_io_channel_unix_new(fileno(stdin));
-
- g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
- key_event_cb, NULL);
- g_io_channel_unref(key_io);
-
-
- g_main_loop_run(main_loop);
-
- cleanup();
- return 0;
-}
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff