Fixed the errors of bluetooth/src/ folder.
Change-Id: Ifc01313a33f894faed3d44ae2b4341b42310b82a
Signed-off-by: h.sandeep <h.sandeep@samsung.com>
#define BT_CHECK_LE_SUPPORT() \
{ \
BT_CHECK_BT_SUPPORT(); \
- LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_SUPPORTED); \
+ LOGE("[%s] NOT_SUPPORTED(0x%08x)", \
+ __FUNCTION__, BT_ERROR_NOT_SUPPORTED); \
return BT_ERROR_NOT_SUPPORTED; \
}
#else
static GSList *advertiser_list = NULL;
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_enable(void)
{
int error_code = BT_ERROR_NONE;
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_enable_adapter());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_disable_adapter());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_recover_adapter());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_reset_adapter());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
{
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_le_enable(void)
{
int error_code = BT_ERROR_NONE;
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_enable_adapter_le());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_disable_adapter_le());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
*adapter_le_state = bluetooth_check_adapter_le();
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_get_address(char **address)
{
BT_CHECK_INPUT_PARAMETER(address);
error_code = _bt_get_error_code(bluetooth_get_local_address(&loc_address));
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- return error_code; //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ return error_code; /* LCOV_EXCL_LINE */
}
error_code = _bt_convert_address_to_string(address, &loc_address);
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- return error_code; //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ return error_code; /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_get_version(char **version)
{
int ret = BT_ERROR_NONE;
BT_CHECK_INPUT_PARAMETER(version);
ret = _bt_get_error_code(bluetooth_get_local_version(&loc_ver));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
}
*version = strdup(loc_ver.version);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
#define BT_ADAPTER_FIRMWARE_INFO_FILE_PATH "/var/lib/bluetooth/bcmtool_log"
#define BT_ADAPTER_STACK_INFO_FILE_PATH "/usr/etc/bluetooth/stack_info"
#define BT_ADAPTER_MAX_BUFFER_SIZE (32767 * 1000)
-//LCOV_EXCL_START
-int bt_adapter_get_local_info(char **chipset, char **firmware, char **stack_version, char **profiles)
+/* LCOV_EXCL_START */
+int bt_adapter_get_local_info(char **chipset, char **firmware,
+ char **stack_version, char **profiles)
{
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(profiles);
if ((fp = fopen(BT_ADAPTER_FIRMWARE_INFO_FILE_PATH, "r")) == NULL) {
- BT_ERR("fopen() is failed(%s)", BT_ADAPTER_FIRMWARE_INFO_FILE_PATH);
+ BT_ERR("fopen() is failed(%s)",
+ BT_ADAPTER_FIRMWARE_INFO_FILE_PATH);
- local_firmware = (char *)malloc(sizeof(char) * 1);
+ local_firmware = (char *)malloc(sizeof(char) *1);
if (local_firmware == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
goto ERROR;
}
local_firmware[0] = '\0';
- local_chipset = (char *)malloc(sizeof(char) * 1);
+ local_chipset = (char *)malloc(sizeof(char) *1);
if (local_chipset == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
goto ERROR;
}
local_chipset[0] = '\0';
ret = BT_ERROR_OPERATION_FAILED;
goto ERROR;
}
- buf = (char *)malloc(sizeof(char) * (lsize + 1));
+ buf = (char *)malloc(sizeof(char) *(lsize + 1));
if (buf == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
goto ERROR;
}
fseek(fp, 0, SEEK_SET);
}
info_size = info_end - info_start - 1;
- local_firmware = (char *)malloc(sizeof(char) * (info_size + 1));
+ local_firmware = (char *)malloc(sizeof(char) *(info_size + 1));
if (local_firmware == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
goto ERROR;
}
}
info_size = info_end - info_start;
- local_chipset = (char *)malloc(sizeof(char) * (info_size + 1));
+ local_chipset = (char *)malloc(sizeof(char) *(info_size + 1));
if (local_chipset == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
goto ERROR;
}
ret = BT_ERROR_OPERATION_FAILED;
goto ERROR;
}
- buf = (char *)malloc(sizeof(char) * (lsize + 1));
+ buf = (char *)malloc(sizeof(char) *(lsize + 1));
if (buf == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
goto ERROR;
}
- local_stack_version = (char *)malloc(sizeof(char) * (info_size + 1));
+ local_stack_version = (char *)malloc(sizeof(char) *(info_size + 1));
if (local_stack_version == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
goto ERROR;
}
- local_profiles = (char *)malloc(sizeof(char) * (info_size + 1));
+ local_profiles = (char *)malloc(sizeof(char) *(info_size + 1));
if (local_profiles == NULL) {
ret = BT_ERROR_OUT_OF_MEMORY;
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
fclose(fp);
return ret;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_get_name(char **name)
{
BT_CHECK_INPUT_PARAMETER(name);
ret = _bt_get_error_code(bluetooth_get_local_name(&loc_name));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
}
*name = strdup(loc_name.name);
if (*name == NULL) {
- BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY); //LCOV_EXCL_LINE
+ BT_ERR("OUT_OF_MEMORY(0x%08x)",
+ BT_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
return BT_ERROR_OUT_OF_MEMORY;
}
loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
ret = _bt_get_error_code(bluetooth_set_local_name(&loc_name));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration)
{
bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
BT_CHECK_INPUT_PARAMETER(mode);
ret = _bt_get_error_code(bluetooth_get_discoverable_mode(&discoverable_mode));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
}
*mode = _bt_get_bt_visibility_mode_e(discoverable_mode);
if (duration == NULL)
return BT_ERROR_NONE;
ret = bluetooth_get_timeout_value(duration);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
}
-int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int timeout_sec)
+int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode,
+ int timeout_sec)
{
bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
int error_code = BT_ERROR_NONE;
return BT_ERROR_INVALID_PARAMETER;
}
- error_code = _bt_get_error_code(bluetooth_set_discoverable_mode(discoverable_mode, timeout_sec));
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_set_discoverable_mode(
+ discoverable_mode, timeout_sec));
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
-int bt_adapter_set_connectable_changed_cb(bt_adapter_connectable_changed_cb callback, void *user_data)
+int bt_adapter_set_connectable_changed_cb(bt_adapter_connectable_changed_cb callback,
+ void *user_data)
{
int ret = BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_CONNECTABLE_CHANGED_EVENT, callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_set_connectable(connectable));
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
-int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data)
+int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb,
+ void *user_data)
{
GPtrArray *dev_list = NULL;
bt_device_info_s *dev_info = NULL;
dev_list = g_ptr_array_new();
if (dev_list == NULL) {
- BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY); //LCOV_EXCL_LINE
+ BT_ERR("OUT_OF_MEMORY(0x%08x)",
+ BT_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
return BT_ERROR_OUT_OF_MEMORY;
}
ret = _bt_get_error_code(bluetooth_get_bonded_device_list(&dev_list));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x) : Failed to get bonded device list", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x) : Failed to get bonded device list",
+ _bt_convert_error_to_string(ret), ret); /* LCOV_EXCL_LINE */
return ret;
}
- for (i = 0; i < dev_list->len; i++) { //LCOV_EXCL_LINE
+ for (i = 0; i < dev_list->len; i++) { /* LCOV_EXCL_LINE */
ptr = g_ptr_array_index(dev_list, i);
if (ptr != NULL) {
- ret = _bt_get_bt_device_info_s(&dev_info, (bluetooth_device_info_t *)ptr);
+ ret = _bt_get_bt_device_info_s(&dev_info,
+ (bluetooth_device_info_t *)ptr);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x) : Failed to get device info", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x) : Failed to get device info",
+ _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
break;
}
_bt_free_bt_device_info_s(dev_info);
break;
}
- _bt_free_bt_device_info_s(dev_info); //LCOV_EXCL_LINE
+ _bt_free_bt_device_info_s(dev_info); /* LCOV_EXCL_LINE */
} else {
- BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE
+ BT_ERR("OPERATION_FAILED(0x%08x)",
+ BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
ret = BT_ERROR_OPERATION_FAILED;
break;
}
return ret;
}
-int bt_adapter_get_bonded_device_info(const char *remote_address, bt_device_info_s **device_info)
+int bt_adapter_get_bonded_device_info(const char *remote_address,
+ bt_device_info_s **device_info)
{
int ret;
bluetooth_device_address_t addr_hex = { {0,} };
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(remote_address); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(remote_address); /* LCOV_EXCL_START */
info = (bluetooth_device_info_t *)malloc(sizeof(bluetooth_device_info_t));
if (info == NULL)
ret = _bt_get_error_code(bluetooth_get_bonded_device(&addr_hex, info));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x) : Failed to run function",
- _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
} else {
ret = _bt_get_bt_device_info_s(device_info, info);
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x) : Failed to get device info",
- _bt_convert_error_to_string(ret),
- ret); //LCOV_EXCL_LINE
+ _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
}
}
free(info);
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_adapter_free_device_info(bt_device_info_s *device_info)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(device_info);
- _bt_free_bt_device_info_s(device_info); //LCOV_EXCL_LINE
+ _bt_free_bt_device_info_s(device_info); /* LCOV_EXCL_LINE */
- return BT_ERROR_NONE; //LCOV_EXCL_LINE
+ return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
int bt_adapter_is_service_used(const char *service_uuid, bool *used)
if (strcmp(service_uuid, OPP_UUID) == 0) {
*used = bluetooth_obex_server_is_activated();
} else {
- ret = _bt_get_error_code(bluetooth_is_service_used(service_uuid, //LCOV_EXCL_LINE
- &is_used));
- *used = is_used ? true : false; //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(bluetooth_is_service_used(
+ service_uuid, /* LCOV_EXCL_LINE */
+ &is_used));
+ *used = is_used ? true : false; /* LCOV_EXCL_LINE */
}
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x) : Failed to run function", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x) : Failed to run function",
+ _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
-int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *user_data)
+int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback,
+ void *user_data)
{
BT_DBG("");
int ret = BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
-//LCOV_EXCL_START
-int bt_adapter_le_set_state_changed_cb(bt_adapter_le_state_changed_cb callback, void *user_data)
+/* LCOV_EXCL_START */
+int bt_adapter_le_set_state_changed_cb(bt_adapter_le_state_changed_cb callback,
+ void *user_data)
{
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
_bt_set_cb(BT_EVENT_LE_STATE_CHANGED, callback, user_data);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
-int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data)
+int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback,
+ void *user_data)
{
int ret = BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
-int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void *user_data)
+int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback,
+ void *user_data)
{
int ret = BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
-int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void *user_data)
+int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback,
+ void *user_data)
{
int ret = BT_ERROR_NONE;
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
- _bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ _bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED,
+ callback, user_data);
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
#ifndef TIZEN_WEARABLE
-int bt_adapter_le_set_device_discovery_state_changed_cb(bt_adapter_le_device_discovery_state_changed_cb callback, void *user_data)
+int bt_adapter_le_set_device_discovery_state_changed_cb(bt_adapter_le_device_discovery_state_changed_cb callback,
+ void *user_data)
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
_bt_le_adapter_init();
- _bt_set_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
+ _bt_set_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED,
+ callback, user_data);
return BT_ERROR_NONE;
}
#endif
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_le_unset_state_changed_cb(void)
{
BT_CHECK_LE_SUPPORT();
_bt_le_adapter_deinit();
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_unset_name_changed_cb(void)
{
return BT_ERROR_NONE;
}
-int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data)
+int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback,
+ void *user_data)
{
int ret = BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED, callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
- error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0,
+ BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_cancel_discovery());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
*is_discovering = (ret == 1) ? true : false;
return BT_ERROR_NONE;
} else {
- ret = _bt_get_error_code(ret); //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(ret); /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
}
}
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_start_le_discovery());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_stop_le_discovery());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code);
}
return error_code;
}
*is_discovering = (ret == 1) ? true : false;
return BT_ERROR_NONE;
} else {
- ret = _bt_get_error_code(ret); //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(ret); /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
}
}
#endif
-int bt_adapter_get_local_oob_data(unsigned char **hash, unsigned char **randomizer,
+int bt_adapter_get_local_oob_data(unsigned char **hash,
+ unsigned char **randomizer,
int *hash_len, int *randomizer_len)
{
int ret = BT_ERROR_NONE;
*hash_len = BLUETOOTH_OOB_DATA_LENGTH;
*randomizer_len = BLUETOOTH_OOB_DATA_LENGTH;
} else {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
}
return ret;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(remote_address); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(remote_address); /* LCOV_EXCL_START */
_bt_convert_address_to_hex(&addr_hex, remote_address);
oob_data.randomizer_len = randomizer_len;
}
- ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex, &oob_data)); //LCOV_EXCL_STOP
- if (BT_ERROR_NONE != ret) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex,
+ &oob_data)); /* LCOV_EXCL_STOP */
+ if (BT_ERROR_NONE != ret) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
- _bt_convert_address_to_hex(&addr_hex, remote_address); //LCOV_EXCL_LINE
+ _bt_convert_address_to_hex(&addr_hex,
+ remote_address); /* LCOV_EXCL_LINE */
- ret = _bt_get_error_code(bluetooth_oob_remove_remote_data(&addr_hex)); //LCOV_EXCL_LINE
- if (BT_ERROR_NONE != ret) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(bluetooth_oob_remove_remote_data(
+ &addr_hex)); /* LCOV_EXCL_LINE */
+ if (BT_ERROR_NONE != ret) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_set_manufacturer_data(char *data, int len)
{
memcpy(&m_data.data[2], data, len);
ret = _bt_get_error_code(bluetooth_set_manufacturer_data(&m_data));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_MANUFACTURER_DATA_CHANGED,
callback, user_data);
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
return BT_ERROR_NONE;
}
-int bt_adapter_le_add_white_list(const char *address, bt_device_address_type_e address_type)
+int bt_adapter_le_add_white_list(const char *address,
+ bt_device_address_type_e address_type)
{
int error_code = BT_ERROR_NONE;
bluetooth_device_address_t addr_hex = { {0,} };
BT_CHECK_INPUT_PARAMETER(address);
_bt_convert_address_to_hex(&addr_hex, address);
- error_code = _bt_get_error_code(bluetooth_add_white_list(&addr_hex, address_type));
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_add_white_list(&addr_hex,
+ address_type));
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_INPUT_PARAMETER(address);
_bt_convert_address_to_hex(&addr_hex, address);
- error_code = _bt_get_error_code(bluetooth_remove_white_list(&addr_hex, address_type));
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_remove_white_list(&addr_hex,
+ address_type));
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_clear_white_list());
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return error_code;
}
return BT_ERROR_INVALID_PARAMETER;
ret = _bt_get_error_code(bluetooth_set_scan_parameters(&scan_params));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- } //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
+ } /* LCOV_EXCL_LINE */
return ret;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_le_create_advertiser(bt_advertiser_h *advertiser)
{
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(advertiser);
- __adv = (bt_advertiser_s*)g_malloc0(sizeof(bt_advertiser_s));
+ __adv = (bt_advertiser_s *)g_malloc0(sizeof(bt_advertiser_s));
if (__adv == NULL) {
- BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY); //LCOV_EXCL_LINE
- return BT_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+ BT_ERR("OUT_OF_MEMORY(0x%08x)",
+ BT_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OUT_OF_MEMORY; /* LCOV_EXCL_LINE */
}
__adv->handle = GPOINTER_TO_INT(__adv);
error_code = bluetooth_set_advertising(__adv->handle, FALSE);
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
advertiser_list = g_slist_remove(advertiser_list, __adv);
int type = 0;
char *p;
- for (i = 0; i < in_len; i++) { //LCOV_EXCL_LINE
+ for (i = 0; i < in_len; i++) { /* LCOV_EXCL_LINE */
len = in_data[i];
if (len <= 0 || i + 1 >= in_len) {
- BT_ERR("Invalid advertising data"); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ BT_ERR("Invalid advertising data"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
type = in_data[i + 1];
break;
}
- i += len; //LCOV_EXCL_LINE
- len = 0; //LCOV_EXCL_LINE
+ i += len; /* LCOV_EXCL_LINE */
+ len = 0; /* LCOV_EXCL_LINE */
}
if (i + len > in_len) {
- BT_ERR("Invalid advertising data"); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ BT_ERR("Invalid advertising data"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
} else if (len == 0 &&
in_type != BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME &&
in_type != BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL) {
- BT_INFO("AD Type 0x%02x data is not set", in_type); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ BT_INFO("AD Type 0x%02x data is not set",
+ in_type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
- p = (char *)malloc(sizeof(char) * (in_len - len));
+ p = (char *)malloc(sizeof(char) *(in_len - len));
if (p == NULL) {
return BT_ERROR_OUT_OF_MEMORY;
}
- memcpy(p, in_data, sizeof(char) * i);
- memcpy(p + i, in_data + i + len, sizeof(char) * (in_len - len - i));
+ memcpy(p, in_data, sizeof(char) *i);
+ memcpy(p + i, in_data + i + len, sizeof(char) *(in_len - len - i));
*data = p;
*data_len = in_len - len;
}
int bt_adapter_le_add_advertising_data(bt_advertiser_h advertiser,
- bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type,
+ bt_adapter_le_packet_type_e pkt_type,
+ bt_adapter_le_packet_data_type_e data_type,
void *data, unsigned int data_size)
{
bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
if ((data == NULL || data_size == 0) &&
(adv_type != BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME &&
adv_type != BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL)) {
- BT_ERR("empty data for packet type %d", pkt_type); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("empty data for packet type %d",
+ pkt_type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
BT_CHECK_INPUT_PARAMETER(advertiser);
/* 2 bytes are required for Length and AD Type */
if (adv_flag_len + *len + adv_ext_len + data_size + 2 > 31) {
- BT_ERR("Quota exceeded"); //LCOV_EXCL_LINE
- return BT_ERROR_QUOTA_EXCEEDED; //LCOV_EXCL_LINE
+ BT_ERR("Quota exceeded"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_QUOTA_EXCEEDED; /* LCOV_EXCL_LINE */
}
if (*len == 0)
*p = NULL;
- new_p = realloc(*p, sizeof(char) * (*len + data_size + 2));
+ new_p = realloc(*p, sizeof(char) *(*len + data_size + 2));
if (new_p == NULL) {
return BT_ERROR_OUT_OF_MEMORY;
}
}
int bt_adapter_le_remove_advertising_data(bt_advertiser_h advertiser,
- bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type)
+ bt_adapter_le_packet_type_e pkt_type,
+ bt_adapter_le_packet_data_type_e data_type)
{
int ret = BT_ERROR_NONE;
bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
break;
case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE:
- p = &__adv->scan_rsp_data; //LCOV_EXCL_LINE
- len = &__adv->scan_rsp_data_len; //LCOV_EXCL_LINE
- system_data_len = &__adv->scan_rsp_system_data_len; //LCOV_EXCL_LINE
- break; //LCOV_EXCL_LINE
+ p = &__adv->scan_rsp_data; /* LCOV_EXCL_LINE */
+ len = &__adv->scan_rsp_data_len; /* LCOV_EXCL_LINE */
+ system_data_len = &__adv->scan_rsp_system_data_len; /* LCOV_EXCL_LINE */
+ break; /* LCOV_EXCL_LINE */
default:
- BT_ERR("Unknown LE packet type : %d", pkt_type); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Unknown LE packet type : %d",
+ pkt_type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
ret = __bt_remove_ad_data_by_type(*p, *len, adv_type, &new_p, &new_len);
if (adv_type == BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME ||
adv_type == BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL)
- *system_data_len -= 1; //LCOV_EXCL_LINE
+ *system_data_len -= 1; /* LCOV_EXCL_LINE */
return ret;
}
-static int __bt_convert_string_to_uuid(const char *string, char **uuid, int *bit)
+static int __bt_convert_string_to_uuid(const char *string,
+ char **uuid, int *bit)
{
char *data;
- if (strlen(string) == 4) { // 16 bit uuid
+ if (strlen(string) == 4) { /* 16 bit uuid */
unsigned short val;
char *stop;
- data = g_malloc0(sizeof(char) * 2);
+ data = g_malloc0(sizeof(char) *2);
if (data == NULL)
- return BT_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+ return BT_ERROR_OUT_OF_MEMORY; /* LCOV_EXCL_LINE */
val = strtol(string, &stop, 16);
val = htons(val);
memcpy(data, &val, 2);
*uuid = data;
- *bit = 16; //LCOV_EXCL_START
- } else if (strlen(string) == 36) { // 128 bit uuid
+ *bit = 16; /* LCOV_EXCL_START */
+ } else if (strlen(string) == 36) { /* 128 bit uuid */
if (string[8] != '-' || string[13] != '-' ||
string[18] != '-' || string[23] != '-') {
- BT_ERR("Invalid UUID"); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Invalid UUID"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
int ret;
unsigned int val0, val4;
unsigned short val1, val2, val3, val5;
- data = g_malloc0(sizeof(char) * 16);
+ data = g_malloc0(sizeof(char) *16);
/* Fix : NULL_RETURNS */
if (data == NULL)
return BT_ERROR_OUT_OF_MEMORY;
ret = sscanf(string, "%08x-%04hx-%04hx-%04hx-%08x%04hx",
- &val0, &val1, &val2, &val3, &val4, &val5);
- if (ret != 6)
- {
+ &val0, &val1, &val2, &val3, &val4, &val5);
+ if (ret != 6) {
g_free(data);
return BT_ERROR_OPERATION_FAILED;
}
*uuid = data;
*bit = 128;
} else {
- BT_ERR("Invalid UUID"); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Invalid UUID"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-static int __bt_convert_byte_ordering(char *data, int data_len, char **converted_data)
+static int __bt_convert_byte_ordering(char *data, int data_len,
+ char **converted_data)
{
char *swp;
int i, j;
}
static int __bt_find_adv_data_type(bt_advertiser_h advertiser,
- bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_advertising_data_type_e data_type,
+ bt_adapter_le_packet_type_e pkt_type,
+ bt_adapter_le_advertising_data_type_e data_type,
char **data_ptr, int *data_len)
{
int type;
if (!adv_data)
return BT_ERROR_OPERATION_FAILED;
- for (i = 0; i <adv_len ; i++) { //LCOV_EXCL_START
+ for (i = 0; i < adv_len ; i++) { /* LCOV_EXCL_START */
len = adv_data[i];
type = adv_data[i + 1];
*data_len = len;
return BT_ERROR_NONE;
} else {
- i = i + adv_data[i]; //LCOV_EXCL_STOP
+ i = i + adv_data[i]; /* LCOV_EXCL_STOP */
}
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
static int __bt_append_adv_type_data(bt_advertiser_h advertiser,
bt_adapter_le_packet_type_e pkt_type,
char *new_data, int new_data_len,
- bt_adapter_le_advertising_data_type_e data_type, char *data_ptr, int data_len)
+ bt_adapter_le_advertising_data_type_e data_type,
+ char *data_ptr, int data_len)
{
int type;
int len;
dest_type = data_ptr[1];
if (data_type != dest_type) {
- BT_ERR("Invalid data type"); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Invalid data type"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
if (adv_flag_len + adv_len + system_data_len + new_data_len > 31) {
- BT_ERR("Quota exceeded"); //LCOV_EXCL_LINE
- return BT_ERROR_QUOTA_EXCEEDED; //LCOV_EXCL_LINE
+ BT_ERR("Quota exceeded"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_QUOTA_EXCEEDED; /* LCOV_EXCL_LINE */
}
new_adv = g_malloc0(adv_len + new_data_len);
rest_data_len = adv_len - (i + len + 1);
if (rest_data_len > 0)
memcpy(new_adv + i + len + 1 + new_data_len,
- &adv_data[i + len + 1], rest_data_len);
+ &adv_data[i + len + 1], rest_data_len);
break;
} else {
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_le_add_advertising_service_uuid(bt_advertiser_h advertiser,
bt_adapter_le_packet_type_e pkt_type, const char *uuid)
if (uuid_bit == 16) {
byte_len = 2;
data_type = BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS;
- } else if (uuid_bit == 128) { //LCOV_EXCL_LINE
- byte_len = 16; //LCOV_EXCL_LINE
- data_type = BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS; //LCOV_EXCL_LINE
+ } else if (uuid_bit == 128) { /* LCOV_EXCL_LINE */
+ byte_len = 16; /* LCOV_EXCL_LINE */
+ data_type = BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS; /* LCOV_EXCL_LINE */
}
__bt_convert_byte_ordering(uuid_ptr, byte_len, &converted_uuid);
__bt_find_adv_data_type(advertiser, pkt_type, data_type, &data_ptr, &data_len);
if (data_ptr) {
- ret = __bt_append_adv_type_data(advertiser, pkt_type, converted_uuid, byte_len, data_type, data_ptr, data_len); //LCOV_EXCL_LINE
+ ret = __bt_append_adv_type_data(advertiser, pkt_type,
+ converted_uuid, byte_len,
+ data_type, data_ptr,
+ data_len); /* LCOV_EXCL_LINE */
} else {
- ret = bt_adapter_le_add_advertising_data(advertiser, pkt_type, data_type, converted_uuid, byte_len);
+ ret = bt_adapter_le_add_advertising_data(advertiser, pkt_type,
+ data_type, converted_uuid,
+ byte_len);
}
g_free(converted_uuid);
if (uuid_bit == 16) {
byte_len = 2;
data_type = BT_ADAPTER_LE_ADVERTISING_DATA_16_BIT_SERVICE_SOLICITATION_UUIDS;
- } else if (uuid_bit == 128) { //LCOV_EXCL_LINE
- byte_len = 16; //LCOV_EXCL_LINE
- data_type = BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_SOLICITATION_UUIDS; //LCOV_EXCL_LINE
+ } else if (uuid_bit == 128) { /* LCOV_EXCL_LINE */
+ byte_len = 16; /* LCOV_EXCL_LINE */
+ data_type = BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_SOLICITATION_UUIDS; /* LCOV_EXCL_LINE */
}
__bt_convert_byte_ordering(uuid_ptr, byte_len, &converted_uuid);
__bt_find_adv_data_type(advertiser, pkt_type, data_type, &data_ptr, &data_len);
if (data_ptr) {
- ret = __bt_append_adv_type_data(advertiser, pkt_type, converted_uuid, byte_len, data_type, data_ptr, data_len); //LCOV_EXCL_LINE
+ ret = __bt_append_adv_type_data(advertiser, pkt_type,
+ converted_uuid, byte_len,
+ data_type, data_ptr,
+ data_len); /* LCOV_EXCL_LINE */
} else {
- ret = bt_adapter_le_add_advertising_data(advertiser, pkt_type, data_type, converted_uuid, byte_len);
+ ret = bt_adapter_le_add_advertising_data(advertiser, pkt_type,
+ data_type, converted_uuid,
+ byte_len);
}
g_free(converted_uuid);
BT_ADAPTER_LE_ADVERTISING_DATA_SERVICE_DATA,
&data_ptr, &data_len);
if (data_ptr) {
- BT_ERR("Aleady existed"); //LCOV_EXCL_LINE
- return BT_ERROR_ALREADY_DONE; //LCOV_EXCL_LINE
+ BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
}
ret = __bt_convert_string_to_uuid(uuid, &uuid_ptr, &uuid_bit);
if (uuid_bit == 16) {
byte_len = 2;
- } else if (uuid_bit == 128) { //LCOV_EXCL_LINE
- BT_ERR("128 bit UUID is not supported"); //LCOV_EXCL_LINE
- g_free(uuid_ptr); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ } else if (uuid_bit == 128) { /* LCOV_EXCL_LINE */
+ BT_ERR("128 bit UUID is not supported"); /* LCOV_EXCL_LINE */
+ g_free(uuid_ptr); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
__bt_convert_byte_ordering(uuid_ptr, byte_len, &converted_uuid);
g_free(uuid_ptr);
- adv_data = g_malloc0(sizeof(char) * (service_data_len + 2));
+ adv_data = g_malloc0(sizeof(char) *(service_data_len + 2));
if (!adv_data) {
- g_free(converted_uuid); //LCOV_EXCL_LINE
+ g_free(converted_uuid); /* LCOV_EXCL_LINE */
return BT_ERROR_OUT_OF_MEMORY;
}
__bt_find_adv_data_type(advertiser, pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_APPEARANCE,
&data_ptr, &data_len);
if (data_ptr) {
- BT_ERR("Aleady existed"); //LCOV_EXCL_LINE
- return BT_ERROR_ALREADY_DONE; //LCOV_EXCL_LINE
+ BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
}
ret = bt_adapter_le_add_advertising_data(advertiser,
BT_ADAPTER_LE_ADVERTISING_DATA_MANUFACTURER_SPECIFIC_DATA,
&data_ptr, &data_len);
if (data_ptr) {
- BT_ERR("Aleady existed"); //LCOV_EXCL_LINE
- return BT_ERROR_ALREADY_DONE; //LCOV_EXCL_LINE
+ BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
}
- adv_data = g_malloc0(sizeof(char) * (manufacturer_data_len + 2));
+ adv_data = g_malloc0(sizeof(char) *(manufacturer_data_len + 2));
if (!adv_data)
return BT_ERROR_OUT_OF_MEMORY;
BT_CHECK_INPUT_PARAMETER(advertiser);
if (!include_name) {
- ret = bt_adapter_le_remove_advertising_data(advertiser, pkt_type, //LCOV_EXCL_LINE
- BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME);
+ ret = bt_adapter_le_remove_advertising_data(advertiser,
+ pkt_type, /* LCOV_EXCL_LINE */
+ BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME);
return ret;
}
BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME,
&data_ptr, &data_len);
if (data_ptr) {
- BT_ERR("Aleady existed"); //LCOV_EXCL_LINE
- return BT_ERROR_ALREADY_DONE; //LCOV_EXCL_LINE
+ BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
}
ret = bt_adapter_le_add_advertising_data(advertiser,
- pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME,
+ pkt_type,
+ BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME,
NULL, 0);
return ret;
BT_CHECK_INPUT_PARAMETER(advertiser);
if (!include_tx_power) {
- ret = bt_adapter_le_remove_advertising_data(advertiser, pkt_type, //LCOV_EXCL_LINE
- BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL);
+ ret = bt_adapter_le_remove_advertising_data(advertiser,
+ pkt_type, /* LCOV_EXCL_LINE */
+ BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL);
return ret;
}
BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL,
&data_ptr, &data_len);
if (data_ptr) {
- BT_ERR("Aleady existed"); //LCOV_EXCL_LINE
- return BT_ERROR_ALREADY_DONE; //LCOV_EXCL_LINE
+ BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
+ return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
}
ret = bt_adapter_le_add_advertising_data(advertiser,
- pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL,
+ pkt_type,
+ BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL,
NULL, 0);
return ret;
break;
default:
- BT_ERR("Unknown LE packet type : %d", pkt_type); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Unknown LE packet type : %d",
+ pkt_type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
if (*p) {
#ifndef TIZEN_WEARABLE
int bt_adapter_le_start_advertising(bt_advertiser_h advertiser,
bt_adapter_le_advertising_params_s *adv_params,
- bt_adapter_le_advertising_state_changed_cb cb, void *user_data)
+ bt_adapter_le_advertising_state_changed_cb cb,
+ void *user_data)
{
int ret = BT_ERROR_NONE;
int error_code;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(advertiser);
- if (__adv->adv_data_len > 0 && __adv->adv_data) { //LCOV_EXCL_START
+ if (__adv->adv_data_len > 0 &&
+ __adv->adv_data) { /* LCOV_EXCL_START */
memcpy(adv.data, __adv->adv_data, __adv->adv_data_len);
- error_code = bluetooth_set_advertising_data(__adv->handle, &adv, __adv->adv_data_len);
+ error_code = bluetooth_set_advertising_data(__adv->handle,
+ &adv, __adv->adv_data_len);
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
- return ret; //LCOV_EXCL_STOP
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
+ return ret; /* LCOV_EXCL_STOP */
}
}
- if (__adv->scan_rsp_data_len > 0 && __adv->scan_rsp_data) { //LCOV_EXCL_START
+ if (__adv->scan_rsp_data_len > 0 &&
+ __adv->scan_rsp_data) { /* LCOV_EXCL_START */
memcpy(resp.data, __adv->scan_rsp_data, __adv->scan_rsp_data_len);
- error_code = bluetooth_set_scan_response_data(__adv->handle, &resp, __adv->scan_rsp_data_len);
+ error_code = bluetooth_set_scan_response_data(__adv->handle,
+ &resp, __adv->scan_rsp_data_len);
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
- return ret; //LCOV_EXCL_STOP
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret);
+ return ret; /* LCOV_EXCL_STOP */
}
}
if (adv_params == NULL) {
- error_code = bluetooth_set_advertising(__adv->handle, TRUE); //LCOV_EXCL_LINE
+ error_code = bluetooth_set_advertising(__adv->handle,
+ TRUE); /* LCOV_EXCL_LINE */
} else {
param.interval_min = adv_params->interval_min;
param.interval_max = adv_params->interval_max;
param.filter_policy = BT_ADAPTER_LE_ADVERTISING_FILTER_DEFAULT;
param.type = BT_ADAPTER_LE_ADVERTISING_CONNECTABLE;
- error_code = bluetooth_set_custom_advertising(__adv->handle, TRUE, ¶m);
+ error_code = bluetooth_set_custom_advertising(__adv->handle,
+ TRUE, ¶m);
}
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
return ret;
}
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(advertiser);
- ret = _bt_get_error_code(bluetooth_set_advertising(__adv->handle, FALSE));
+ ret = _bt_get_error_code(bluetooth_set_advertising(__adv->handle,
+ FALSE));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
}
return ret;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(advertiser);
- if (__adv->adv_data_len > 0 && __adv->adv_data) { //LCOV_EXCL_START
+ if (__adv->adv_data_len > 0 &&
+ __adv->adv_data) { /* LCOV_EXCL_START */
memcpy(adv.data, __adv->adv_data, __adv->adv_data_len);
- error_code = bluetooth_set_advertising_data(__adv->handle, &adv, __adv->adv_data_len);
+ error_code = bluetooth_set_advertising_data(__adv->handle,
+ &adv, __adv->adv_data_len);
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_STOP
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_STOP */
return ret;
}
}
- if (__adv->scan_rsp_data_len > 0 && __adv->scan_rsp_data) { //LCOV_EXCL_START
+ if (__adv->scan_rsp_data_len > 0 &&
+ __adv->scan_rsp_data) { /* LCOV_EXCL_START */
memcpy(resp.data, __adv->scan_rsp_data, __adv->scan_rsp_data_len);
- error_code = bluetooth_set_scan_response_data(__adv->handle, &resp, __adv->scan_rsp_data_len);
+ error_code = bluetooth_set_scan_response_data(__adv->handle,
+ &resp, __adv->scan_rsp_data_len);
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_STOP
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_STOP */
return ret;
}
}
param.interval_max = interval;
param.filter_policy = __adv->adv_params.filter_policy;
param.type = __adv->adv_params.type;
- error_code = bluetooth_set_custom_advertising(__adv->handle, TRUE, ¶m);
+ error_code = bluetooth_set_custom_advertising(__adv->handle,
+ TRUE, ¶m);
ret = _bt_get_error_code(error_code);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
return ret;
}
return ret;
}
-void _bt_adapter_le_invoke_advertising_state_cb(int handle, int result, bt_adapter_le_advertising_state_e adv_state)
+void _bt_adapter_le_invoke_advertising_state_cb(int handle, int result,
+ bt_adapter_le_advertising_state_e adv_state)
{
const GSList *l = NULL;
bt_advertiser_s *__adv = (bt_advertiser_s *)l->data;
if (__adv->handle == handle) {
if (__adv->cb == NULL) {
- BT_ERR("advertiser cb is NULL"); //LCOV_EXCL_LINE
- return; //LCOV_EXCL_LINE
+ BT_ERR("advertiser cb is NULL"); /* LCOV_EXCL_LINE */
+ return; /* LCOV_EXCL_LINE */
}
- __adv->cb(result, (bt_advertiser_h)__adv, adv_state, __adv->user_data);
+ __adv->cb(result, (bt_advertiser_h)__adv,
+ adv_state, __adv->user_data);
return;
}
}
- BT_ERR("No available advertiser"); //LCOV_EXCL_LINE
+ BT_ERR("No available advertiser"); /* LCOV_EXCL_LINE */
}
int bt_adapter_le_set_advertising_mode(bt_advertiser_h advertiser,
error_code = _bt_get_error_code(bluetooth_check_privilege_advertising_parameter());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- return BT_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ return BT_ERROR_PERMISSION_DENIED; /* LCOV_EXCL_LINE */
}
- // TODO : Before set the mode, check the inprogress status
+ /* TODO : Before set the mode, check the inprogress status */
__adv->adv_params.mode = mode;
return error_code;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_le_set_advertising_filter_policy(bt_advertiser_h advertiser,
bt_adapter_le_advertising_filter_policy_e filter_policy)
{
error_code = _bt_get_error_code(bluetooth_check_privilege_advertising_parameter());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
return BT_ERROR_PERMISSION_DENIED;
}
- // TODO : Before set the filter policy, check the inprogress status
+ /* TODO : Before set the filter policy, check the inprogress status */
__adv->adv_params.filter_policy = filter_policy;
return error_code;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
-int bt_adapter_le_set_advertising_connectable(bt_advertiser_h advertiser, bool connectable)
+int bt_adapter_le_set_advertising_connectable(bt_advertiser_h advertiser,
+ bool connectable)
{
int error_code = BT_ERROR_NONE;
bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(advertiser);
- error_code = _bt_get_error_code(bluetooth_check_privilege_advertising_parameter());
+ error_code = _bt_get_error_code(
+ bluetooth_check_privilege_advertising_parameter());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
- return BT_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
+ return BT_ERROR_PERMISSION_DENIED; /* LCOV_EXCL_LINE */
}
if (connectable)
- __adv->adv_params.type = BT_ADAPTER_LE_ADVERTISING_CONNECTABLE; //LCOV_EXCL_LINE
+ __adv->adv_params.type = BT_ADAPTER_LE_ADVERTISING_CONNECTABLE; /* LCOV_EXCL_LINE */
else
__adv->adv_params.type = BT_ADAPTER_LE_ADVERTISING_SCANNABLE;
- // TODO : Before set the type, check the inprogress status
+ /* TODO : Before set the type, check the inprogress status */
return error_code;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_le_enable_privacy(bool enable_privacy)
{
int error_code = BT_ERROR_NONE;
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- error_code = _bt_get_error_code(bluetooth_enable_le_privacy(enable_privacy));
+ error_code = _bt_get_error_code(
+ bluetooth_enable_le_privacy(enable_privacy));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
}
return error_code;
}
-static void __bt_adapter_le_convert_scan_filter(bluetooth_le_scan_filter_t *dest, bt_le_scan_filter_s *src)
+static void __bt_adapter_le_convert_scan_filter(
+ bluetooth_le_scan_filter_t *dest,
+ bt_le_scan_filter_s *src)
{
int bit;
char *data;
if (src->device_address) {
dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
- _bt_convert_address_to_hex(&dest->device_address, src->device_address);
+ _bt_convert_address_to_hex(&dest->device_address,
+ src->device_address);
}
if (src->device_name) {
dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME;
- strncpy(dest->device_name, src->device_name, BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX);
+ strncpy(dest->device_name, src->device_name,
+ BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX);
dest->device_name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1] = '\0';
}
if (src->service_uuid) {
- if (__bt_convert_string_to_uuid(src->service_uuid, &data, &bit) == BT_ERROR_NONE) {
+ if (__bt_convert_string_to_uuid(src->service_uuid,
+ &data, &bit) == BT_ERROR_NONE) {
dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID;
if (bit == 16)
dest->service_uuid.data_len = 2;
else
dest->service_uuid.data_len = 16;
- memcpy(dest->service_uuid.data.data, data, dest->service_uuid.data_len);
+ memcpy(dest->service_uuid.data.data, data,
+ dest->service_uuid.data_len);
g_free(data);
dest->service_uuid_mask.data_len = dest->service_uuid.data_len;
if (src->service_uuid_mask) {
- __bt_convert_string_to_uuid(src->service_uuid_mask, &data, &bit);
- memcpy(dest->service_uuid_mask.data.data, data, dest->service_uuid_mask.data_len);
+ __bt_convert_string_to_uuid(
+ src->service_uuid_mask, &data, &bit);
+ memcpy(dest->service_uuid_mask.data.data, data,
+ dest->service_uuid_mask.data_len);
g_free(data);
} else {
- memset(dest->service_uuid_mask.data.data, 0xFF, dest->service_uuid_mask.data_len);
+ memset(dest->service_uuid_mask.data.data, 0xFF,
+ dest->service_uuid_mask.data_len);
}
}
}
if (src->service_solicitation_uuid) {
- if (__bt_convert_string_to_uuid(src->service_solicitation_uuid, &data, &bit) == BT_ERROR_NONE) {
+ if (__bt_convert_string_to_uuid(src->service_solicitation_uuid,
+ &data, &bit) == BT_ERROR_NONE) {
dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
if (bit == 16)
dest->service_solicitation_uuid.data_len = 2;
else
dest->service_solicitation_uuid.data_len = 16;
- memcpy(dest->service_solicitation_uuid.data.data, data, dest->service_solicitation_uuid.data_len);
+ memcpy(dest->service_solicitation_uuid.data.data, data,
+ dest->service_solicitation_uuid.data_len);
g_free(data);
dest->service_solicitation_uuid_mask.data_len = dest->service_solicitation_uuid.data_len;
if (src->service_solicitation_uuid_mask) {
- __bt_convert_string_to_uuid(src->service_solicitation_uuid_mask, &data, &bit);
+ __bt_convert_string_to_uuid(
+ src->service_solicitation_uuid_mask,
+ &data, &bit);
memcpy(dest->service_solicitation_uuid_mask.data.data, data, dest->service_solicitation_uuid_mask.data_len);
g_free(data);
} else {
if (src->service_data_uuid) {
char *service_uuid;
int uuid_len;
- if (__bt_convert_string_to_uuid(src->service_data_uuid, &service_uuid, &bit) == BT_ERROR_NONE) {
+ if (__bt_convert_string_to_uuid(src->service_data_uuid,
+ &service_uuid, &bit) == BT_ERROR_NONE) {
dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
if (bit == 16)
uuid_len = 2;
memcpy(dest->service_data.data.data, service_uuid, uuid_len);
g_free(service_uuid);
- memcpy(dest->service_data.data.data + uuid_len, src->service_data, src->service_data_len);
- dest->service_data.data_len = uuid_len + src->service_data_len;
-
- dest->service_data_mask.data_len = uuid_len + src->service_data_len;
- memset(dest->service_data_mask.data.data, 0xFF, uuid_len);
+ memcpy(dest->service_data.data.data + uuid_len,
+ src->service_data, src->service_data_len);
+ dest->service_data.data_len = uuid_len
+ + src->service_data_len;
+
+ dest->service_data_mask.data_len = uuid_len
+ + src->service_data_len;
+ memset(dest->service_data_mask.data.data,
+ 0xFF, uuid_len);
if (src->service_data_mask)
memcpy(dest->service_data_mask.data.data + uuid_len, src->service_data_mask, src->service_data_len);
else
dest->manufacturer_id = src->manufacturer_id;
if (src->manufacturer_data) {
- memcpy(dest->manufacturer_data.data.data, src->manufacturer_data, src->manufacturer_data_len);
+ memcpy(dest->manufacturer_data.data.data,
+ src->manufacturer_data,
+ src->manufacturer_data_len);
dest->manufacturer_data.data_len = src->manufacturer_data_len;
dest->manufacturer_data_mask.data_len = src->manufacturer_data_len;
if (src->manufacturer_data_mask)
- memcpy(dest->manufacturer_data_mask.data.data, src->manufacturer_data_mask, src->manufacturer_data_len);
+ memcpy(dest->manufacturer_data_mask.data.data,
+ src->manufacturer_data_mask,
+ src->manufacturer_data_len);
else
- memset(dest->manufacturer_data_mask.data.data, 0xFF, src->manufacturer_data_len);
+ memset(dest->manufacturer_data_mask.data.data,
+ 0xFF, src->manufacturer_data_len);
}
}
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_adapter_le_start_scan(bt_adapter_le_scan_result_cb cb, void *user_data)
{
error_code = _bt_get_error_code(bluetooth_start_le_discovery());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
}
return error_code;
}
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_stop_le_discovery());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
}
return error_code;
}
int bt_adapter_le_get_scan_result_service_uuids(const bt_adapter_le_device_scan_result_info_s *info,
- bt_adapter_le_packet_type_e pkt_type, char ***uuids, int *count)
+ bt_adapter_le_packet_type_e pkt_type,
+ char ***uuids, int *count)
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(info);
- BT_CHECK_INPUT_PARAMETER(uuids); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(uuids); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(count);
int adv_length = 0;
if (uuid_count == 0)
return BT_ERROR_NO_DATA;
- *uuids = g_malloc0(sizeof(char*) * uuid_count);
+ *uuids = g_malloc0(sizeof(char *) *uuid_count);
/* Fix : NULL_RETURNS */
if (*uuids == NULL)
return BT_ERROR_OUT_OF_MEMORY;
if (uuid_size != 0) {
for (i = 0; i < (field_len - 1); i += uuid_size) {
if (uuid_size == 2) {
- (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 4 + 1);
+ (*uuids)[uuid_index] = g_malloc0(sizeof(char) *4 + 1);
/* Fix : NULL_RETURNS */
if ((*uuids)[uuid_index] == NULL)
return BT_ERROR_OUT_OF_MEMORY;
- snprintf((*uuids)[uuid_index], 5, "%2.2X%2.2X", remain_data[i+3], remain_data[i+2]);
+ snprintf((*uuids)[uuid_index], 5,
+ "%2.2X%2.2X",
+ remain_data[i+3],
+ remain_data[i+2]);
} else {
- (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 36 + 1);
+ (*uuids)[uuid_index] = g_malloc0(sizeof(char) *36 + 1);
/* Fix : NULL_RETURNS */
if ((*uuids)[uuid_index] == NULL)
return BT_ERROR_OUT_OF_MEMORY;
}
return BT_ERROR_NONE;
-} //LCOV_EXCL_STOP
+} /* LCOV_EXCL_STOP */
int bt_adapter_le_get_scan_result_device_name(const bt_adapter_le_device_scan_result_info_s *info,
bt_adapter_le_packet_type_e pkt_type, char **name)
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(info); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(name);
int adv_length = 0;
field_len = adv_data[0];
if (adv_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME ||
adv_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_SHORT_LOCAL_NAME) {
- *name = g_malloc0(sizeof(char) * field_len);
+ *name = g_malloc0(sizeof(char) *field_len);
/* Fix : NULL_RETURNS */
if (*name == NULL)
return BT_ERROR_OUT_OF_MEMORY;
adv_data += field_len + 1;
}
- return BT_ERROR_NO_DATA; //LCOV_EXCL_STOP
+ return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
}
int bt_adapter_le_get_scan_result_tx_power_level(const bt_adapter_le_device_scan_result_info_s *info,
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(info); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(power_level);
int adv_length = 0;
adv_data += field_len + 1;
}
- return BT_ERROR_NO_DATA; //LCOV_EXCL_STOP
+ return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
}
int bt_adapter_le_get_scan_result_service_solicitation_uuids(const bt_adapter_le_device_scan_result_info_s *info,
- bt_adapter_le_packet_type_e pkt_type, char ***uuids, int *count)
+ bt_adapter_le_packet_type_e pkt_type,
+ char ***uuids, int *count)
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(info); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(uuids);
BT_CHECK_INPUT_PARAMETER(count);
if (uuid_count == 0)
return BT_ERROR_NO_DATA;
- *uuids = g_malloc0(sizeof(char*) * uuid_count);
+ *uuids = g_malloc0(sizeof(char *) *uuid_count);
/* Fix : NULL_RETURNS */
if (*uuids == NULL)
return BT_ERROR_OUT_OF_MEMORY;
if (uuid_size != 0) {
for (i = 0; i < (field_len - 1); i += uuid_size) {
if (uuid_size == 2) {
- (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 4 + 1);
+ (*uuids)[uuid_index] = g_malloc0(sizeof(char) *4 + 1);
/* Fix : NULL_RETURNS */
if ((*uuids)[uuid_index] == NULL)
return BT_ERROR_OUT_OF_MEMORY;
- snprintf((*uuids)[uuid_index], 5, "%2.2X%2.2X", remain_data[i+3], remain_data[i+2]);
+ snprintf((*uuids)[uuid_index], 5,
+ "%2.2X%2.2X", remain_data[i+3],
+ remain_data[i+2]);
} else {
- (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 36 + 1);
+ (*uuids)[uuid_index] = g_malloc0(sizeof(char) *36 + 1);
/* Fix : NULL_RETURNS */
if ((*uuids)[uuid_index] == NULL)
return BT_ERROR_OUT_OF_MEMORY;
remain_data += field_len + 1;
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_adapter_le_get_scan_result_service_data_list(const bt_adapter_le_device_scan_result_info_s *info,
- bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_service_data_s **data_list, int *count)
+ bt_adapter_le_packet_type_e pkt_type,
+ bt_adapter_le_service_data_s **data_list, int *count)
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(info); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(count);
int adv_length = 0;
if (data_count == 0)
return BT_ERROR_NO_DATA;
- *data_list = g_malloc0(sizeof(bt_adapter_le_service_data_s) * data_count);
+ *data_list = g_malloc0(sizeof(bt_adapter_le_service_data_s) *data_count);
/* Fix : NULL_RETURNS */
if (*data_list == NULL)
return BT_ERROR_OUT_OF_MEMORY;
while (remain_len > 0) {
field_len = remain_data[0];
if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_SERVICE_DATA) {
- (*data_list)[data_index].service_uuid = g_malloc0(sizeof(char) * 4 + 1);
- snprintf((*data_list)[data_index].service_uuid, 5, "%2.2X%2.2X", remain_data[3], remain_data[2]);
+ (*data_list)[data_index].service_uuid = g_malloc0(sizeof(char) *4 + 1);
+ snprintf((*data_list)[data_index].service_uuid, 5,
+ "%2.2X%2.2X", remain_data[3], remain_data[2]);
- (*data_list)[data_index].service_data = g_memdup(&remain_data[4], field_len - 3);
+ (*data_list)[data_index].service_data = g_memdup(
+ &remain_data[4], field_len - 3);
(*data_list)[data_index].service_data_len = field_len - 3;
data_index++;
remain_data += field_len + 1;
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-int bt_adapter_le_free_service_data_list(bt_adapter_le_service_data_s *data_list, int count)
+int bt_adapter_le_free_service_data_list(bt_adapter_le_service_data_s *data_list,
+ int count)
{
int i;
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(data_list); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(data_list); /* LCOV_EXCL_START */
for (i = 0; i < count; i++) {
g_free(data_list[i].service_uuid);
}
g_free(data_list);
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_adapter_le_get_scan_result_appearance(const bt_adapter_le_device_scan_result_info_s *info,
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(info); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(appearance);
int adv_length = 0;
adv_data += field_len + 1;
}
- return BT_ERROR_NO_DATA; //LCOV_EXCL_STOP
+ return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
}
int bt_adapter_le_get_scan_result_manufacturer_data(const bt_adapter_le_device_scan_result_info_s *info,
- bt_adapter_le_packet_type_e pkt_type, int *manufacturer_id, char **manufacturer_data, int *manufacturer_data_len)
+ bt_adapter_le_packet_type_e pkt_type,
+ int *manufacturer_id, char **manufacturer_data,
+ int *manufacturer_data_len)
{
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(info);
- BT_CHECK_INPUT_PARAMETER(manufacturer_id); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(manufacturer_id); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(manufacturer_data);
BT_CHECK_INPUT_PARAMETER(manufacturer_data_len);
*manufacturer_id = remain_data[3] << 8;
*manufacturer_id += remain_data[2];
- *manufacturer_data = g_memdup(&adv_data[4], field_len - 3);
+ *manufacturer_data = g_memdup(&adv_data[4],
+ field_len - 3);
*manufacturer_data_len = field_len - 3;
return BT_ERROR_NONE;
remain_data += field_len + 1;
}
- return BT_ERROR_NO_DATA; //LCOV_EXCL_STOP
+ return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_adapter_le_create_scan_filter(bt_scan_filter_h *scan_filter)
{
bt_le_scan_filter_s *__filter = NULL;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(scan_filter);
- __filter = (bt_le_scan_filter_s*)g_malloc0(sizeof(bt_le_scan_filter_s));
+ __filter = (bt_le_scan_filter_s *)g_malloc0(sizeof(bt_le_scan_filter_s));
if (__filter == NULL) {
- BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY); //LCOV_EXCL_LINE
+ BT_ERR("OUT_OF_MEMORY(0x%08x)",
+ BT_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
return BT_ERROR_OUT_OF_MEMORY;
}
return BT_ERROR_NONE;
}
-int bt_adapter_le_scan_filter_set_device_address(bt_scan_filter_h scan_filter, const char *address)
+int bt_adapter_le_scan_filter_set_device_address(bt_scan_filter_h scan_filter,
+ const char *address)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(name);
if (strlen(name) > 29) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
return BT_ERROR_NONE;
}
-int bt_adapter_le_scan_filter_set_service_uuid(bt_scan_filter_h scan_filter, const char *uuid)
+int bt_adapter_le_scan_filter_set_service_uuid(bt_scan_filter_h scan_filter,
+ const char *uuid)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(mask);
if (strlen(uuid) != strlen(mask)) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
return BT_ERROR_NONE;
}
-int bt_adapter_le_scan_filter_set_service_solicitation_uuid(bt_scan_filter_h scan_filter, const char *uuid)
+int bt_adapter_le_scan_filter_set_service_solicitation_uuid(bt_scan_filter_h scan_filter,
+ const char *uuid)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(mask);
if (strlen(uuid) != strlen(mask)) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
}
int bt_adapter_le_scan_filter_set_service_data(bt_scan_filter_h scan_filter,
- const char *uuid, const char *data, unsigned int data_len)
+ const char *uuid, const char *data,
+ unsigned int data_len)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(data);
if (data_len > 27) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
}
int bt_adapter_le_scan_filter_set_service_data_with_mask(bt_scan_filter_h scan_filter,
- const char *uuid, const char *data, unsigned int data_len, const char *mask, unsigned int mask_len)
+ const char *uuid, const char *data, unsigned int data_len,
+ const char *mask, unsigned int mask_len)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(mask);
if (data_len != mask_len || data_len > 27) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
}
int bt_adapter_le_scan_filter_set_manufacturer_data(bt_scan_filter_h scan_filter,
- int manufacturer_id, const char *data, unsigned int data_len)
+ int manufacturer_id, const char *data,
+ unsigned int data_len)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(scan_filter);
if (manufacturer_id < 0 || manufacturer_id > 0xFFFF) {
- BT_ERR("manufacturer_id is %.8x(0x%08x)", manufacturer_id, BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("manufacturer_id is %.8x(0x%08x)", manufacturer_id,
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
if (data_len > 27) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
}
int bt_adapter_le_scan_filter_set_manufacturer_data_with_mask(bt_scan_filter_h scan_filter,
- int manufacturer_id, const char *data, unsigned int data_len, const char *mask, unsigned int mask_len)
+ int manufacturer_id, const char *data,
+ unsigned int data_len, const char *mask,
+ unsigned int mask_len)
{
bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_INPUT_PARAMETER(mask);
if (manufacturer_id < 0 || manufacturer_id > 0xFFFF) {
- BT_ERR("manufacturer_id is %.8x(0x%08x)", manufacturer_id, BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("manufacturer_id is %.8x(0x%08x)", manufacturer_id,
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
if (data_len != mask_len || data_len > 27) {
- BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER); //LCOV_EXCL_LINE
+ BT_ERR("INVALID_PARAMETER(0x%08x)",
+ BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
return BT_ERROR_INVALID_PARAMETER;
}
int bt_adapter_le_register_scan_filter(bt_scan_filter_h scan_filter)
{
int error_code = BT_ERROR_NONE;
- bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s*)scan_filter;
+ bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
bluetooth_le_scan_filter_t filter;
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(scan_filter);
if (bluetooth_is_le_scanning() == TRUE) {
- BT_ERR("NOW_IN_PROGRESS(0x%08x)", BT_ERROR_NOW_IN_PROGRESS); //LCOV_EXCL_LINE
+ BT_ERR("NOW_IN_PROGRESS(0x%08x)",
+ BT_ERROR_NOW_IN_PROGRESS); /* LCOV_EXCL_LINE */
return BT_ERROR_NOW_IN_PROGRESS;
}
__bt_adapter_le_convert_scan_filter(&filter, __filter);
- error_code = _bt_get_error_code(bluetooth_register_scan_filter(&filter, &__filter->slot_id));
+ error_code = _bt_get_error_code(bluetooth_register_scan_filter(&filter,
+ &__filter->slot_id));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
}
return error_code;
int bt_adapter_le_unregister_scan_filter(bt_scan_filter_h scan_filter)
{
int error_code = BT_ERROR_NONE;
- bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s*)scan_filter;
+ bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(scan_filter);
if (bluetooth_is_le_scanning() == TRUE) {
- BT_ERR("NOW_IN_PROGRESS(0x%08x)", BT_ERROR_NOW_IN_PROGRESS); //LCOV_EXCL_LINE
+ BT_ERR("NOW_IN_PROGRESS(0x%08x)",
+ BT_ERROR_NOW_IN_PROGRESS); /* LCOV_EXCL_LINE */
return BT_ERROR_NOW_IN_PROGRESS;
}
error_code = _bt_get_error_code(bluetooth_unregister_scan_filter(__filter->slot_id));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
BT_CHECK_LE_SUPPORT();
BT_CHECK_INIT_STATUS();
if (bluetooth_is_le_scanning() == TRUE) {
- BT_ERR("NOW_IN_PROGRESS(0x%08x)", BT_ERROR_NOW_IN_PROGRESS); //LCOV_EXCL_LINE
+ BT_ERR("NOW_IN_PROGRESS(0x%08x)",
+ BT_ERROR_NOW_IN_PROGRESS); /* LCOV_EXCL_LINE */
return BT_ERROR_NOW_IN_PROGRESS;
}
error_code = _bt_get_error_code(bluetooth_unregister_all_scan_filters());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
+ error_code); /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
bluetooth_le_read_maximum_data_length(&max_le_datalength));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
return ret;
}
}
int bt_adapter_le_write_host_suggested_default_data_length(
- const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
+ const unsigned int def_tx_Octets,
+ const unsigned int def_tx_Time)
{
int ret = BT_ERROR_NONE;
def_tx_Octets, def_tx_Time));
if (ret != BT_ERROR_NONE)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
return ret;
}
bluetooth_le_read_suggested_default_data_length(&data_values));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
return ret;
}
return ret;
}
-int bt_adapter_set_authentication_req_cb(bt_adapter_authentication_req_cb callback, void *user_data)
+int bt_adapter_set_authentication_req_cb(bt_adapter_authentication_req_cb callback,
+ void *user_data)
{
BT_CHECK_INIT_STATUS();
_bt_set_cb(BT_EVENT_AUTHENTICATION_REQUEST, callback, user_data);
_bt_unset_cb(BT_EVENT_AUTHENTICATION_REQUEST);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
#endif
static bool is_audio_ag_initialized = false;
-#if defined (TIZEN_HFP_DISABLE) && defined (TIZEN_A2DP_DISABLE)
+#if defined(TIZEN_HFP_DISABLE) && defined(TIZEN_A2DP_DISABLE)
#define BT_CHECK_AUDIO_SUPPORT() \
{ \
BT_CHECK_BT_SUPPORT(); \
#endif
#define BT_CHECK_AUDIO_INIT_STATUS() \
- if (is_audio_a2dp_initialized != true && is_audio_ag_initialized != true) \
- { \
+ if (is_audio_a2dp_initialized != true && is_audio_ag_initialized != true) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
#define BT_CHECK_A2DP_INIT_STATUS() \
- if (is_audio_a2dp_initialized != true) \
- { \
+ if (is_audio_a2dp_initialized != true) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
#define BT_CHECK_HF_INIT_STATUS() \
- if (is_audio_hf_initialized != true) \
- { \
+ if (is_audio_hf_initialized != true) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
#define BT_CHECK_AG_INIT_STATUS() \
- if (is_audio_ag_initialized != true) \
- { \
+ if (is_audio_ag_initialized != true) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
* subsequent check ins.*/
int _bt_convert_telephony_error_code(int error)
{
- switch(error) {
+ switch (error) {
case BLUETOOTH_TELEPHONY_ERROR_NONE:
return BT_ERROR_NONE;
case BLUETOOTH_TELEPHONY_ERROR_INVALID_PARAM:
error = bluetooth_audio_init(_bt_audio_event_proxy, NULL);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
else
is_audio_a2dp_initialized = true;
error = bluetooth_telephony_init((void *)_bt_telephony_event_proxy, NULL);
error = _bt_convert_telephony_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("[%s] (0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("[%s] (0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
else
is_audio_ag_initialized = true;
#endif
error = bluetooth_audio_deinit();
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
is_audio_a2dp_initialized = false;
BT_CHECK_AUDIO_SUPPORT();
BT_CHECK_INIT_STATUS();
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
if (type == BT_AUDIO_PROFILE_TYPE_HSP_HFP) {
BT_CHECK_HFP_SUPPORT();
BT_CHECK_AG_INIT_STATUS();
BT_CHECK_A2DP_SUPPORT();
BT_CHECK_A2DP_INIT_STATUS();
} else if (type == BT_AUDIO_PROFILE_TYPE_ALL) {
-#if defined (TIZEN_HFP_DISABLE) || defined (TELEPHONY_DISABLED)
+#if defined(TIZEN_HFP_DISABLE) || defined(TELEPHONY_DISABLED)
BT_CHECK_A2DP_INIT_STATUS();
BT_ERR("HSP NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
type = BT_AUDIO_PROFILE_TYPE_A2DP;
BT_CHECK_INPUT_PARAMETER(remote_address);
_bt_convert_address_to_hex(&addr_hex, remote_address);
- switch(type) {
+ switch (type) {
#ifndef TELEPHONY_DISABLED
case BT_AUDIO_PROFILE_TYPE_HSP_HFP:
error = bluetooth_ag_connect(&addr_hex);
}
return error;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type)
{
BT_CHECK_AUDIO_SUPPORT();
BT_CHECK_INIT_STATUS();
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
if (type == BT_AUDIO_PROFILE_TYPE_HSP_HFP) {
BT_CHECK_HFP_SUPPORT();
BT_CHECK_AG_INIT_STATUS();
BT_CHECK_A2DP_SUPPORT();
BT_CHECK_A2DP_INIT_STATUS();
} else if (type == BT_AUDIO_PROFILE_TYPE_ALL) {
-#if defined (TIZEN_HFP_DISABLE) || defined (TELEPHONY_DISABLED)
+#if defined(TIZEN_HFP_DISABLE) || defined(TELEPHONY_DISABLED)
BT_CHECK_A2DP_INIT_STATUS();
BT_ERR("HSP NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
type = BT_AUDIO_PROFILE_TYPE_A2DP;
BT_CHECK_INPUT_PARAMETER(remote_address);
_bt_convert_address_to_hex(&addr_hex, remote_address);
- switch(type) {
+ switch (type) {
#ifndef TELEPHONY_DISABLED
case BT_AUDIO_PROFILE_TYPE_HSP_HFP:
error = bluetooth_ag_disconnect(&addr_hex);
}
return error;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_cb callback, void *user_data)
{
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_ag_notify_speaker_gain(int gain)
{
int error;
_bt_unset_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_ag_open_sco(void)
{
BT_CHECK_HFP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_AG_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_AG_INIT_STATUS(); /* LCOV_EXCL_START */
error = bluetooth_telephony_audio_open();
error = _bt_convert_telephony_error_code(error);
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
int bt_ag_close_sco(void)
BT_CHECK_HFP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_AG_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_AG_INIT_STATUS(); /* LCOV_EXCL_START */
error = bluetooth_telephony_audio_close();
error = _bt_convert_telephony_error_code(error);
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
int bt_ag_is_sco_opened(bool *opened)
{
BT_CHECK_HFP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_AG_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_AG_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(opened);
if (bluetooth_telephony_is_sco_connected())
*opened = true;
else
- *opened = false; //LCOV_EXCL_STOP
+ *opened = false; /* LCOV_EXCL_STOP */
return BT_ERROR_NONE;
}
{
BT_CHECK_HFP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_AG_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_AG_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(callback);
_bt_set_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS, callback, user_data);
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_ag_unset_sco_state_changed_cb(void)
{
BT_CHECK_HFP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_AG_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_AG_INIT_STATUS(); /* LCOV_EXCL_START */
if (_bt_check_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS) == true)
_bt_unset_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS);
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, const char *phone_number)
{
int error;
BT_CHECK_AG_INIT_STATUS();
BT_INFO("call_id [%d] / event [%d]", call_id, event);
- switch(event) {
+ switch (event) {
case BT_AG_CALL_EVENT_IDLE:
error = bluetooth_telephony_call_end(call_id);
break;
}
return error;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_ag_notify_voice_recognition_state(bool state)
{
BT_CHECK_HFP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_AG_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_AG_INIT_STATUS(); /* LCOV_EXCL_START */
if (state)
error = bluetooth_telephony_start_voice_recognition();
else
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback,
void *user_data)
{
}
return error;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
#ifdef TIZEN_WEARABLE
int bt_hf_initialize(void)
BT_INFO("event [%d]", event);
- switch(event) {
+ switch (event) {
case BT_HF_CALL_EVENT_IDLE:
error = bluetooth_hf_terminate_call();
break;
static void __bt_hf_free_call_status_info(void *data)
{
- bt_hf_call_status_info_s *call_info = (bt_hf_call_status_info_s*)data;
+ bt_hf_call_status_info_s *call_info = (bt_hf_call_status_info_s *)data;
g_free(call_info->number);
g_free(call_info);
}
#endif
#define BT_CHECK_AVRCP_TARGET_INIT_STATUS() \
- if (__bt_check_avrcp_target_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
+ if (__bt_check_avrcp_target_init_status() == BT_ERROR_NOT_INITIALIZED) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
int __bt_check_avrcp_target_init_status(void)
{
if (is_avrcp_target_initialized != true) {
- BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); //LCOV_EXCL_LINE
- return BT_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE
+ BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); /* LCOV_EXCL_LINE */
+ return BT_ERROR_NOT_INITIALIZED; /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
}
#define BT_CHECK_AVRCP_CONTROL_INIT_STATUS() \
- if (__bt_check_avrcp_control_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
+ if (__bt_check_avrcp_control_init_status() == BT_ERROR_NOT_INITIALIZED) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
int __bt_check_avrcp_control_init_status(void)
{
if (is_avrcp_control_initialized != true) {
- BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); //LCOV_EXCL_LINE
- return BT_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE
+ BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); /* LCOV_EXCL_LINE */
+ return BT_ERROR_NOT_INITIALIZED; /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
* subsequent check ins.*/
int _bt_convert_avrcp_error_code(int error)
{
- switch(error) {
+ switch (error) {
case BT_MEDIA_ERROR_NONE:
return BT_ERROR_NONE;
case BT_MEDIA_ERROR_INTERNAL:
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
- return error; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
+ return error; /* LCOV_EXCL_LINE */
}
is_avrcp_target_initialized = true;
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
- return error; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
+ return error; /* LCOV_EXCL_LINE */
}
is_avrcp_target_initialized = false;
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_avrcp_control_initialize(bt_avrcp_control_connection_state_changed_cb callback,
void *user_data)
{
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
- return error; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
+ return error; /* LCOV_EXCL_LINE */
}
is_avrcp_control_initialized = true;
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
- return error; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
+ return error; /* LCOV_EXCL_LINE */
}
is_avrcp_control_initialized = false;
error = bluetooth_media_control_connect(&addr_hex);
error = _bt_get_error_code(error);
if (error != BT_ERROR_NONE)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = bluetooth_media_control_disconnect(&addr_hex);
error = _bt_get_error_code(error);
if (error != BT_ERROR_NONE)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = _bt_convert_avrcp_error_code(error);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
g_free((gpointer)track);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb callback, void *user_data)
{
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_avrcp_set_song_position_changed_cb(bt_avrcp_song_position_changed_cb callback, void *user_data)
{
BT_CHECK_AVRCP_SUPPORT();
_bt_unset_cb(BT_EVENT_AVRCP_TRACK_INFO_CHANGED);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
/*
* Internal Functions
*/
-static void __bt_event_proxy(int event, bluetooth_event_param_t * param, void *user_data);
+static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data);
static void __bt_le_event_proxy(int event, bluetooth_event_param_t *param, void *user_data);
static int __bt_get_cb_index(int event);
static void __bt_convert_lower_to_upper(char *origin);
BT_CHECK_BT_SUPPORT();
if (is_initialized != true) {
if (bluetooth_register_callback(&__bt_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) {
- BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
is_initialized = true;
}
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
if (bluetooth_unregister_callback() != BLUETOOTH_ERROR_NONE) {
- BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
is_initialized = false;
return BT_ERROR_NONE;
if (bluetooth_le_register_callback(&__bt_le_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) {
- BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
is_le_initialized = true;
if (!_bt_check_cb(BT_EVENT_LE_STATE_CHANGED) &&
!_bt_check_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED)) {
- if (bluetooth_le_unregister_callback() != BLUETOOTH_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE
- return BT_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
+ if (bluetooth_le_unregister_callback() != BLUETOOTH_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
+ return BT_ERROR_OPERATION_FAILED; /* LCOV_EXCL_LINE */
}
- is_le_initialized = false; //LCOV_EXCL_LINE
+ is_le_initialized = false; /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
return BT_ERROR_REMOTE_DEVICE_NOT_FOUND;
case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR:
return BT_ERROR_SERVICE_SEARCH_FAILED;
- case BLUETOOTH_ERROR_PERMISSION_DEINED :
+ case BLUETOOTH_ERROR_PERMISSION_DEINED:
return BT_ERROR_PERMISSION_DENIED;
case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
return BT_ERROR_SERVICE_NOT_FOUND;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_t *source_dev)
{
int i = 0;
(*dest_dev)->bt_class.minor_device_class = source_dev->device_class.minor_class;
(*dest_dev)->bt_class.major_service_class_mask = source_dev->device_class.service_class;
if (source_dev->service_index > 0) {
- (*dest_dev)->service_uuid = (char **)malloc(sizeof(char *) * source_dev->service_index);
+ (*dest_dev)->service_uuid = (char **)malloc(sizeof(char *) *source_dev->service_index);
if ((*dest_dev)->service_uuid != NULL) {
for (i = 0; i < source_dev->service_index; i++) {
(*dest_dev)->service_uuid[i] =
free(device_info);
device_info = NULL;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int _bt_convert_address_to_string(char **addr_str, bluetooth_device_address_t *addr_hex)
{
if (*addr_str != NULL) {
return BT_ERROR_NONE;
} else {
- return BT_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
+ return BT_ERROR_OUT_OF_MEMORY; /* LCOV_EXCL_LINE */
}
}
unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = { 0, };
if (addr_str == NULL || addr_str[0] == '\0')
- return; //LCOV_EXCL_LINE
+ return; /* LCOV_EXCL_LINE */
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) {
- BT_ERR("Invalid format string - [%s]", addr_str); //LCOV_EXCL_LINE
+ BT_ERR("Invalid format string - [%s]", addr_str); /* LCOV_EXCL_LINE */
}
for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++) {
case BT_ERROR_CANCELLED:
return "CANCELLED";
case BT_ERROR_INVALID_PARAMETER:
- return "INVALID_PARAMETER"; //LCOV_EXCL_LINE
+ return "INVALID_PARAMETER"; /* LCOV_EXCL_LINE */
case BT_ERROR_OUT_OF_MEMORY:
- return "OUT_OF_MEMORY"; //LCOV_EXCL_LINE
+ return "OUT_OF_MEMORY"; /* LCOV_EXCL_LINE */
case BT_ERROR_RESOURCE_BUSY:
- return "RESOURCE_BUSY"; //LCOV_EXCL_LINE
+ return "RESOURCE_BUSY"; /* LCOV_EXCL_LINE */
case BT_ERROR_TIMED_OUT:
- return "TIMED_OUT"; //LCOV_EXCL_LINE
+ return "TIMED_OUT"; /* LCOV_EXCL_LINE */
case BT_ERROR_NOW_IN_PROGRESS:
- return "NOW_IN_PROGRESS"; //LCOV_EXCL_LINE
+ return "NOW_IN_PROGRESS"; /* LCOV_EXCL_LINE */
case BT_ERROR_NOT_INITIALIZED:
return "NOT_INITIALIZED";
case BT_ERROR_NOT_ENABLED:
- return "DEVICE_NOT_ENABLED"; //LCOV_EXCL_LINE
+ return "DEVICE_NOT_ENABLED"; /* LCOV_EXCL_LINE */
case BT_ERROR_ALREADY_DONE:
- return "ALREADY_DONE"; //LCOV_EXCL_LINE
+ return "ALREADY_DONE"; /* LCOV_EXCL_LINE */
case BT_ERROR_OPERATION_FAILED:
- return "OPERATION_FAILED"; //LCOV_EXCL_LINE
+ return "OPERATION_FAILED"; /* LCOV_EXCL_LINE */
case BT_ERROR_NOT_IN_PROGRESS:
return "NOT_IN_PROGRESS";
case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
return "REMOTE_DEVICE_NOT_BONDED";
case BT_ERROR_AUTH_REJECTED:
- return "AUTH_REJECTED"; //LCOV_EXCL_LINE
+ return "AUTH_REJECTED"; /* LCOV_EXCL_LINE */
case BT_ERROR_AUTH_FAILED:
- return "AUTH_FAILED"; //LCOV_EXCL_LINE
+ return "AUTH_FAILED"; /* LCOV_EXCL_LINE */
case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
- return "REMOTE_DEVICE_NOT_FOUND"; //LCOV_EXCL_LINE
+ return "REMOTE_DEVICE_NOT_FOUND"; /* LCOV_EXCL_LINE */
case BT_ERROR_SERVICE_SEARCH_FAILED:
- return "SERVICE_SEARCH_FAILED"; //LCOV_EXCL_LINE
+ return "SERVICE_SEARCH_FAILED"; /* LCOV_EXCL_LINE */
case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED:
- return "REMOTE_DEVICE_NOT_CONNECTED"; //LCOV_EXCL_LINE
+ return "REMOTE_DEVICE_NOT_CONNECTED"; /* LCOV_EXCL_LINE */
case BT_ERROR_PERMISSION_DENIED:
- return "PERMISSION_DENIED"; //LCOV_EXCL_LINE
+ return "PERMISSION_DENIED"; /* LCOV_EXCL_LINE */
case BT_ERROR_SERVICE_NOT_FOUND:
- return "SERVICE_NOT_FOUND"; //LCOV_EXCL_LINE
+ return "SERVICE_NOT_FOUND"; /* LCOV_EXCL_LINE */
case BT_ERROR_NOT_SUPPORTED:
- return "NOT_SUPPORTD"; //LCOV_EXCL_LINE
+ return "NOT_SUPPORTD"; /* LCOV_EXCL_LINE */
default:
- return "UNKNOWN"; //LCOV_EXCL_LINE
+ return "UNKNOWN"; /* LCOV_EXCL_LINE */
}
}
case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
return BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
- return BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE; //LCOV_EXCL_LINE
+ return BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE; /* LCOV_EXCL_LINE */
default:
return BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
}
* Internal Functions
*/
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source)
{
int i = 0;
}
if (source->service_index > 0) {
- (*dest)->service_uuid = (char **)malloc(sizeof(char *) * source->service_index);
+ (*dest)->service_uuid = (char **)malloc(sizeof(char *) *source->service_index);
if ((*dest)->service_uuid == NULL) {
__bt_free_bt_device_sdp_info_s(*dest);
return BT_ERROR_OUT_OF_MEMORY;
new_param.user_data = param->user_data;
__bt_event_proxy(event, &new_param, user_data);
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data)
{
event_index = __bt_get_cb_index(event);
if (event == BLUETOOTH_EVENT_GATT_CONNECTED) {
- const GSList *clients = NULL; //LCOV_EXCL_START
+ const GSList *clients = NULL; /* LCOV_EXCL_START */
const GSList *l = NULL;
int ret;
}
}
g_free(device_addr);
- device_addr = NULL; //LCOV_EXCL_STOP
+ device_addr = NULL; /* LCOV_EXCL_STOP */
}
if (event == BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED || event == BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED ||
switch (event) {
case BLUETOOTH_EVENT_ENABLED:
- BT_INFO("bt_adapter_state_changed_cb() will be called with BT_ADAPTER_ENABLED"); //LCOV_EXCL_LINE
+ BT_INFO("bt_adapter_state_changed_cb() will be called with BT_ADAPTER_ENABLED"); /* LCOV_EXCL_LINE */
((bt_adapter_state_changed_cb) bt_event_slot_container[event_index].callback)
(_bt_get_error_code(param->result), BT_ADAPTER_ENABLED, bt_event_slot_container[event_index].user_data);
break;
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
case BLUETOOTH_EVENT_DISABLED:
BT_INFO("bt_adapter_state_changed_cb() will be called with BT_ADAPTER_DISABLED");
((bt_adapter_state_changed_cb) bt_event_slot_container[event_index].callback)
BT_INFO("bt_device_service_searched_cb() will be called");
__bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t *)(param->param_data));
error_code = _bt_get_error_code(param->result);
- // In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
+ /* In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED. */
if (error_code == BT_ERROR_OPERATION_FAILED)
error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
((bt_device_service_searched_cb)bt_event_slot_container[event_index].callback)
__bt_free_bt_device_sdp_info_s(sdp_info);
break;
case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
- /*BT_INFO("bt_socket_data_received_cb() will be * called"); */
+ /* BT_INFO("bt_socket_data_received_cb() will be * called"); */
((bt_socket_data_received_cb)bt_event_slot_container[event_index].callback)
((bt_socket_received_data_s *)(param->param_data), bt_event_slot_container[event_index].user_data);
break;
return;
for (server_list = _bt_gatt_get_server_list() ; server_list; server_list = g_slist_next(server_list)) {
- bt_gatt_server_s *serv = (bt_gatt_server_s*)server_list->data;
+ bt_gatt_server_s *serv = (bt_gatt_server_s *)server_list->data;
GSList *service_list = NULL;
for (service_list = serv->services; service_list; service_list = g_slist_next(service_list)) {
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service_list->data;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service_list->data;
GSList *char_list = NULL;
for (char_list = svc->characteristics; char_list; char_list = g_slist_next(char_list)) {
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)char_list->data;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)char_list->data;
if (chr->path && strcmp(char_val->char_handle, chr->path) == 0) {
g_free(chr->value);
chr->value = NULL;
/* TODO : Fix build error temporary */
if (chr->server_value_changed_cb)
chr->server_value_changed_cb(NULL, (bt_gatt_server_h)serv, (bt_gatt_h)chr,
- 0, (char*)char_val->char_value, char_val->val_len,
+ 0, (char *)char_val->char_value, char_val->val_len,
chr->server_value_changed_user_data);
}
}
}
break;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
case BLUETOOTH_EVENT_ADVERTISING_STARTED:
BT_INFO("BLUETOOTH_EVENT_ADVERTISING_STARTED");
adv_handle = (int *)(param->param_data);
_bt_get_error_code(param->result), BT_ADAPTER_LE_ADVERTISING_STOPPED);
break;
- case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED: //LCOV_EXCL_START
+ case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED: /* LCOV_EXCL_START */
BT_INFO("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
((bt_adapter_manufacturer_data_changed_cb)bt_event_slot_container[event_index].callback)
bt_event_slot_container[event_index].user_data);
if (device_addr != NULL)
- free(device_addr); //LCOV_EXCL_STOP
+ free(device_addr); /* LCOV_EXCL_STOP */
break;
#ifdef TIZEN_WEARABLE
case BLUETOOTH_PBAP_CONNECTED: {
}
#endif
case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED: {
- BT_DBG("BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED"); //LCOV_EXCL_LINE
- ((bt_le_ipsp_init_state_changed_cb)bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
- (_bt_get_error_code(param->result), *(bool *)(param->param_data), //LCOV_EXCL_LINE
+ BT_DBG("BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED"); /* LCOV_EXCL_LINE */
+ ((bt_le_ipsp_init_state_changed_cb)bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
+ (_bt_get_error_code(param->result), *(bool *)(param->param_data), /* LCOV_EXCL_LINE */
bt_event_slot_container[event_index].user_data);
break;
}
switch (event) {
case BLUETOOTH_EVENT_LE_ENABLED:
- BT_INFO("BLUETOOTH_EVENT_LE_ENABLED"); //LCOV_EXCL_LINE
- ((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
+ BT_INFO("BLUETOOTH_EVENT_LE_ENABLED"); /* LCOV_EXCL_LINE */
+ ((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
(_bt_get_error_code(param->result), BT_ADAPTER_LE_ENABLED, bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_LE_DISABLED:
- BT_INFO("BLUETOOTH_EVENT_LE_DISABLED"); //LCOV_EXCL_LINE
- ((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
+ BT_INFO("BLUETOOTH_EVENT_LE_DISABLED"); /* LCOV_EXCL_LINE */
+ ((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
(_bt_get_error_code(param->result), BT_ADAPTER_LE_DISABLED, bt_event_slot_container[event_index].user_data);
break;
#ifndef TIZEN_WEARABLE
case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
- BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_STARTED"); //LCOV_EXCL_LINE
- ((bt_adapter_le_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
+ BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_STARTED"); /* LCOV_EXCL_LINE */
+ ((bt_adapter_le_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
(_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED, NULL, bt_event_slot_container[event_index].user_data);
break;
case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
- BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED"); //LCOV_EXCL_LINE
- ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
+ BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED"); /* LCOV_EXCL_LINE */
+ ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
(_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data);
break;
#endif
#ifndef TIZEN_WEARABLE
event_index = BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED;
if (bt_event_slot_container[event_index].callback != NULL) {
- if (__bt_get_bt_adapter_le_device_discovery_info_s(&discovery_info, (bluetooth_le_device_info_t *)(param->param_data)) == BT_ERROR_NONE) { //LCOV_EXCL_LINE
- ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
+ if (__bt_get_bt_adapter_le_device_discovery_info_s(&discovery_info, (bluetooth_le_device_info_t *)(param->param_data)) == BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
(_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, discovery_info, bt_event_slot_container[event_index].user_data);
- __bt_free_bt_adapter_le_device_discovery_info_s(discovery_info); //LCOV_EXCL_LINE
+ __bt_free_bt_adapter_le_device_discovery_info_s(discovery_info); /* LCOV_EXCL_LINE */
} else {
- ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) //LCOV_EXCL_LINE
+ ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) /* LCOV_EXCL_LINE */
(_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, NULL, bt_event_slot_container[event_index].user_data);
}
}
}
}
-//LCOV_EXCL_START
-static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info) {
+/* LCOV_EXCL_START */
+static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info)
+{
int i;
BT_CHECK_INPUT_PARAMETER(source_info);
(*discovery_info)->bt_class.major_service_class_mask = source_info->device_class.service_class;
if (source_info->service_index > 0) {
- (*discovery_info)->service_uuid = (char **)malloc(sizeof(char *) * source_info->service_index);
+ (*discovery_info)->service_uuid = (char **)malloc(sizeof(char *) *source_info->service_index);
if ((*discovery_info)->service_uuid != NULL) {
for (i = 0; i < source_info->service_index; i++) {
(*discovery_info)->service_uuid[i] = strdup(source_info->uuids[i]);
free(discovery_info);
discovery_info = NULL;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
static int __bt_get_bt_adapter_le_device_scan_info_s(
bt_adapter_le_device_scan_result_info_s **scan_info,
bluetooth_le_device_info_t *source_info)
if (source_info->addr_type == 0x02)
(*scan_info)->address_type = BT_DEVICE_RANDOM_ADDRESS;
else
- (*scan_info)->address_type = BT_DEVICE_PUBLIC_ADDRESS; //LCOV_EXCL_LINE
+ (*scan_info)->address_type = BT_DEVICE_PUBLIC_ADDRESS; /* LCOV_EXCL_LINE */
(*scan_info)->rssi = (int)source_info->rssi;
(*scan_info)->adv_data_len = source_info->adv_ind_data.data_len;
if ((*scan_info)->adv_data_len > 0) {
(*scan_info)->adv_data = malloc(source_info->adv_ind_data.data_len);
memcpy((*scan_info)->adv_data, source_info->adv_ind_data.data.data, source_info->adv_ind_data.data_len);
} else {
- (*scan_info)->adv_data = NULL; //LCOV_EXCL_LINE
+ (*scan_info)->adv_data = NULL; /* LCOV_EXCL_LINE */
}
(*scan_info)->scan_data_len = source_info->scan_resp_data.data_len;
if ((*scan_info)->scan_data_len > 0) {
- (*scan_info)->scan_data = malloc(source_info->scan_resp_data.data_len); //LCOV_EXCL_LINE
- memcpy((*scan_info)->scan_data, source_info->scan_resp_data.data.data, source_info->scan_resp_data.data_len); //LCOV_EXCL_LINE
+ (*scan_info)->scan_data = malloc(source_info->scan_resp_data.data_len); /* LCOV_EXCL_LINE */
+ memcpy((*scan_info)->scan_data, source_info->scan_resp_data.data.data, source_info->scan_resp_data.data_len); /* LCOV_EXCL_LINE */
} else {
(*scan_info)->scan_data = NULL;
}
free(scan_info);
scan_info = NULL;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
#ifndef TIZEN_WEARABLE
static int __bt_get_bt_adapter_le_device_discovery_info_s(
bt_adapter_le_device_discovery_info_s **le_discovery_info,
return -1;
}
#endif
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
static int __bt_get_cb_index(int event)
{
switch (event) {
return BT_EVENT_STATE_CHANGED;
case BLUETOOTH_EVENT_LE_ENABLED:
case BLUETOOTH_EVENT_LE_DISABLED:
- return BT_EVENT_LE_STATE_CHANGED; //LCOV_EXCL_LINE
+ return BT_EVENT_LE_STATE_CHANGED; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
- return BT_EVENT_NAME_CHANGED; //LCOV_EXCL_LINE
+ return BT_EVENT_NAME_CHANGED; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
- return BT_EVENT_VISIBILITY_MODE_CHANGED; //LCOV_EXCL_LINE
+ return BT_EVENT_VISIBILITY_MODE_CHANGED; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
- return BT_EVENT_VISIBILITY_DURATION_CHANGED; //LCOV_EXCL_LINE
+ return BT_EVENT_VISIBILITY_DURATION_CHANGED; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_DISCOVERY_STARTED:
case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
return BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED;
case BLUETOOTH_EVENT_BONDING_FINISHED:
- return BT_EVENT_BOND_CREATED; //LCOV_EXCL_LINE
- //LCOV_EXCL_START
+ return BT_EVENT_BOND_CREATED; /* LCOV_EXCL_LINE */
+ /* LCOV_EXCL_START */
case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
return BT_EVENT_BOND_DESTROYED;
case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
return BT_EVENT_GATT_CLIENT_READ_DESCRIPTOR;
case BLUETOOTH_EVENT_GATT_WRITE_DESC:
return BT_EVENT_GATT_CLIENT_WRITE_DESCRIPTOR;
- //LCOV_EXCL_STOP
+ /* LCOV_EXCL_STOP */
case BLUETOOTH_EVENT_ADVERTISING_STARTED:
case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
return BT_EVENT_ADVERTISING_STATE_CHANGED;
case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
- return BT_EVENT_MANUFACTURER_DATA_CHANGED; //LCOV_EXCL_LINE
+ return BT_EVENT_MANUFACTURER_DATA_CHANGED; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
- return BT_EVENT_CONNECTABLE_CHANGED_EVENT; //LCOV_EXCL_LINE
+ return BT_EVENT_CONNECTABLE_CHANGED_EVENT; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_IPSP_CONNECTED:
case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
- return BT_EVENT_IPSP_CONNECTION_STATUS; //LCOV_EXCL_LINE
+ return BT_EVENT_IPSP_CONNECTION_STATUS; /* LCOV_EXCL_LINE */
case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
- return BT_EVENT_LE_DATA_LENGTH_CHANGED; //LCOV_EXCL_LINE
+ return BT_EVENT_LE_DATA_LENGTH_CHANGED; /* LCOV_EXCL_LINE */
#ifdef TIZEN_WEARABLE
case BLUETOOTH_PBAP_CONNECTED:
return BT_EVENT_PBAP_CONNECTION_STATUS;
return -1;
}
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
static void __bt_convert_lower_to_upper(char *origin)
{
int length = strlen(origin);
}
ret = bt_gatt_descriptor_create(desc_property.uuid, 0,
- (char*)desc_property.val, (int)desc_property.val_len,
+ (char *)desc_property.val, (int)desc_property.val_len,
(bt_gatt_h *)&desc);
if (ret != BT_ERROR_NONE) {
characteristic->descriptors = desc_list;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(device_address);
- _bt_convert_address_to_hex(&addr_hex, device_address); //LCOV_EXCL_START
+ _bt_convert_address_to_hex(&addr_hex, device_address); /* LCOV_EXCL_START */
error_code = _bt_get_error_code(bluetooth_bond_device(&addr_hex));
if (error_code != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
}
return error_code;
-} //LCOV_EXCL_STOP
+} /* LCOV_EXCL_STOP */
int bt_device_cancel_bonding(void)
{
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
- error_code = _bt_get_error_code(bluetooth_cancel_bonding()); //LCOV_EXCL_LINE
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_cancel_bonding()); /* LCOV_EXCL_LINE */
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
}
- return error_code; //LCOV_EXCL_LINE
+ return error_code; /* LCOV_EXCL_LINE */
}
int bt_device_destroy_bond(const char *device_address)
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(device_address); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(device_address); /* LCOV_EXCL_LINE */
- _bt_convert_address_to_hex(&addr_hex, device_address); //LCOV_EXCL_LINE
- error_code = _bt_get_error_code(bluetooth_unbond_device(&addr_hex)); //LCOV_EXCL_LINE
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ _bt_convert_address_to_hex(&addr_hex, device_address); /* LCOV_EXCL_LINE */
+ error_code = _bt_get_error_code(bluetooth_unbond_device(&addr_hex)); /* LCOV_EXCL_LINE */
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
}
- return error_code; //LCOV_EXCL_LINE
+ return error_code; /* LCOV_EXCL_LINE */
}
int bt_device_set_alias(const char *device_address, const char *alias)
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(device_address);
- BT_CHECK_INPUT_PARAMETER(alias); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(alias); /* LCOV_EXCL_LINE */
- _bt_convert_address_to_hex(&addr_hex, device_address); //LCOV_EXCL_LINE
- error_code = _bt_get_error_code(bluetooth_set_alias(&addr_hex, alias)); //LCOV_EXCL_LINE
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ _bt_convert_address_to_hex(&addr_hex, device_address); /* LCOV_EXCL_LINE */
+ error_code = _bt_get_error_code(bluetooth_set_alias(&addr_hex, alias)); /* LCOV_EXCL_LINE */
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
}
- return error_code; //LCOV_EXCL_LINE
+ return error_code; /* LCOV_EXCL_LINE */
}
int bt_device_set_authorization(const char *device_address, bt_device_authorization_e authorization)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(device_address);
- _bt_convert_address_to_hex(&addr_hex, device_address); //LCOV_EXCL_LINE
- if (authorization == BT_DEVICE_AUTHORIZED) //LCOV_EXCL_LINE
- trusted = TRUE; //LCOV_EXCL_LINE
+ _bt_convert_address_to_hex(&addr_hex, device_address); /* LCOV_EXCL_LINE */
+ if (authorization == BT_DEVICE_AUTHORIZED) /* LCOV_EXCL_LINE */
+ trusted = TRUE; /* LCOV_EXCL_LINE */
- error_code = _bt_get_error_code(bluetooth_authorize_device(&addr_hex, trusted)); //LCOV_EXCL_LINE
- if (error_code != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_authorize_device(&addr_hex, trusted)); /* LCOV_EXCL_LINE */
+ if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
}
- return error_code; //LCOV_EXCL_LINE
+ return error_code; /* LCOV_EXCL_LINE */
}
int bt_device_start_service_search(const char *device_address)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(device_address);
- _bt_convert_address_to_hex(&addr_hex, device_address); //LCOV_EXCL_START
+ _bt_convert_address_to_hex(&addr_hex, device_address); /* LCOV_EXCL_START */
ret = _bt_get_error_code(bluetooth_search_service(&addr_hex));
/* In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED. */
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_connected_profile callback, void *user_data)
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_LINE */
- _bt_convert_address_to_hex(&addr_hex, remote_address); //LCOV_EXCL_LINE
+ _bt_convert_address_to_hex(&addr_hex, remote_address); /* LCOV_EXCL_LINE */
while (profiles[i] != 0) {
ret = _bt_get_error_code(bluetooth_is_device_connected(&addr_hex,
profiles[i],
&is_connected));
- if (ret != BT_ERROR_NONE) { //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); /* LCOV_EXCL_LINE */
return ret;
}
- if (is_connected == TRUE) { //LCOV_EXCL_LINE
- if (!callback(profiles[i], user_data)) //LCOV_EXCL_LINE
+ if (is_connected == TRUE) { /* LCOV_EXCL_LINE */
+ if (!callback(profiles[i], user_data)) /* LCOV_EXCL_LINE */
break;
}
- i++; //LCOV_EXCL_LINE
+ i++; /* LCOV_EXCL_LINE */
}
return BT_ERROR_NONE;
*connected_status = is_connected ? true : false;
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); /* LCOV_EXCL_LINE */
return ret;
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_device_get_connection_state(const char *remote_address,
bt_device_connection_link_type_e link_type, bool *connected)
{
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_device_set_connection_state_changed_cb(bt_device_connection_state_changed_cb callback, void *user_data)
{
BT_CHECK_BT_SUPPORT();
_bt_unset_cb(BT_EVENT_DEVICE_CONNECTION_STATUS);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_device_le_conn_update(const char *device_address,
- const bt_le_conn_update_s *parameters)
+ const bt_le_conn_update_s *parameters)
{
bluetooth_device_address_t addr_hex = { {0,} };
bluetooth_le_connection_param_t param = { 0 };
return ret;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_device_get_service_mask_from_uuid_list(char **uuids,
int no_of_service,
bt_service_class_t *service_mask_list)
parts = g_strsplit(uuids[i], "-", -1);
if (parts == NULL || parts[0] == NULL) {
- g_strfreev(parts); //LCOV_EXCL_LINE
- continue; //LCOV_EXCL_LINE
+ g_strfreev(parts); /* LCOV_EXCL_LINE */
+ continue; /* LCOV_EXCL_LINE */
}
service = g_ascii_strtoull(parts[0], NULL, 16);
break;
case BLUETOOTH_LAP_PROFILE_UUID:
- service_mask |= BT_SC_LAP_SERVICE_MASK; //LCOV_EXCL_LINE
- break; //LCOV_EXCL_LINE
-//LCOV_EXCL_START
+ service_mask |= BT_SC_LAP_SERVICE_MASK; /* LCOV_EXCL_LINE */
+ break; /* LCOV_EXCL_LINE */
+/* LCOV_EXCL_START */
case BLUETOOTH_DUN_PROFILE_UUID:
service_mask |= BT_SC_DUN_SERVICE_MASK;
break;
case BLUETOOTH_OBEX_PRINTING_STATUS_UUID:
service_mask |= BT_SC_BPP_SERVICE_MASK;
break;
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
case BLUETOOTH_HCR_PROFILE_UUID:
service_mask |= BT_SC_NONE;
break;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_passkey_reply(char *passkey, bool authentication_reply)
{
BT_CHECK_INIT_STATUS();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
- bluetooth_device_address_t addr_hex = {{0,}};
+ bluetooth_device_address_t addr_hex = { {0, } };
- //Range for host suggested txtime is 0x001B-0x00FB and
- // txocets is 0x0148- 0x0848 as per BT 4.2 spec
+ /* Range for host suggested txtime is 0x001B-0x00FB and
+ * txocets is 0x0148- 0x0848 as per BT 4.2 spec */
if ((max_tx_Octets < 0x001B || max_tx_Octets > 0x00FB)
&& (max_tx_Time < 0x0148 || max_tx_Time > 0x0848)) {
return BT_ERROR_INVALID_PARAMETER;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
#define BT_CHECK_GATT_SUPPORT() \
{ \
BT_CHECK_BT_SUPPORT(); \
- LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_SUPPORTED); \
+ LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, \
+ BT_ERROR_NOT_SUPPORTED); \
return BT_ERROR_NOT_SUPPORTED; \
}
#else
#define BT_CHECK_GATT_SUPPORT()
#endif
-#define BT_CHECK_GATT_SERVER_INIT_STATUS() \
- if (__bt_check_gatt_server_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
- LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+#define BT_CHECK_GATT_SERVER_INIT_STATUS() { \
+ if (__bt_check_gatt_server_init_status() == BT_ERROR_NOT_INITIALIZED) { \
+ LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, \
+ BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
- }
-//LCOV_EXCL_START
+ } \
+}
+
+/* LCOV_EXCL_START */
int __bt_check_gatt_server_init_status(void)
{
if (is_gatt_server_initialized != true) {
switch (len) {
case 4: /* UUID 16bits */
- uuid128 = g_strdup_printf("0000%s-0000-1000-8000-00805F9B34FB", uuid);
+ uuid128 = g_strdup_printf("0000%s-0000-1000-8000-00805F9B34FB",
+ uuid);
break;
case 8: /* UUID 32bits */
- uuid128 = g_strdup_printf("%s-0000-1000-8000-00805F9B34FB", uuid);
+ uuid128 = g_strdup_printf("%s-0000-1000-8000-00805F9B34FB",
+ uuid);
break;
case 36: /* UUID 128bits */
return BT_ERROR_NONE;
}
-const GSList* _bt_gatt_get_client_list(void)
+const GSList *_bt_gatt_get_client_list(void)
{
return gatt_client_list;
}
-const GSList* _bt_gatt_get_server_list(void)
+const GSList *_bt_gatt_get_server_list(void)
{
return gatt_server_list;
}
BT_INFO("Legacy GATT Client APIs");
return true;
}
-//LCOV_EXCL_STOP
+
+/* LCOV_EXCL_STOP */
int bt_gatt_foreach_primary_services(const char *remote_address,
bt_gatt_primary_service_cb callback,
void *user_data)
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
prim_svc = g_new0(bt_gatt_handle_info_t, 1);
BT_INFO("handle: %s", prim_svc->handle[i]);
if (foreach_call == true &&
- !callback((bt_gatt_attribute_h)prim_svc->handle[i], user_data)) {
+ !callback((bt_gatt_attribute_h)prim_svc->handle[i],
+ user_data)) {
foreach_call = false;
}
g_free(prim_svc->handle);
g_free(prim_svc);
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_discover_characteristics(bt_gatt_attribute_h service,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
ret = _bt_get_error_code(bluetooth_gatt_discover_service_characteristics((const char *)service));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_CHARACTERISTIC_DISCOVERED_LEGACY, callback, user_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_CHARACTERISTIC_DISCOVERED_LEGACY,
+ callback, user_data);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_get_service_uuid(bt_gatt_attribute_h service, char **uuid)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- memset(&property, 0x00, sizeof(bt_gatt_service_property_t)); //LCOV_EXCL_START
+ memset(&property, 0x00, sizeof(bt_gatt_service_property_t)); /* LCOV_EXCL_START */
- ret = _bt_get_error_code(bluetooth_gatt_get_service_property((const char *)service, &property));
+ ret = _bt_get_error_code(bluetooth_gatt_get_service_property((const char *)service,
+ &property));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
*uuid = g_strdup(property.uuid);
- if (property.include_handles.count != 0 && property.include_handles.handle) {
+ if (property.include_handles.count != 0 &&
+ property.include_handles.handle) {
for (i = 0; i < property.include_handles.count; i++) {
g_free(property.include_handles.handle[i]);
}
g_free(property.include_handles.handle);
}
- if (property.char_handle.count != 0 && property.char_handle.handle) {
+ if (property.char_handle.count != 0 &&
+ property.char_handle.handle) {
for (i = 0; i < property.char_handle.count; i++) {
g_free(property.char_handle.handle[i]);
}
}
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_foreach_included_services(bt_gatt_attribute_h service,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
memset(&property, 0x00, sizeof(bt_gatt_service_property_t));
- ret = _bt_get_error_code(bluetooth_gatt_get_service_property((const char *)service, &property));
+ ret = _bt_get_error_code(bluetooth_gatt_get_service_property((const char *)service,
+ &property));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- if (property.char_handle.count != 0 && property.char_handle.handle) {
+ if (property.char_handle.count != 0 &&
+ property.char_handle.handle) {
for (i = 0; i < property.char_handle.count; i++) {
g_free(property.char_handle.handle[i]);
}
}
g_free(property.include_handles.handle);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_set_characteristic_changed_cb(bt_gatt_characteristic_changed_cb callback,
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(callback);
- _bt_set_cb(BT_EVENT_GATT_CLIENT_VALUE_CHANGED_LEGACY, callback, user_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_VALUE_CHANGED_LEGACY,
+ callback, user_data);
return BT_ERROR_NONE;
}
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- ret = _bt_get_error_code(bluetooth_gatt_watch_characteristics((const char *)service)); //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(bluetooth_gatt_watch_characteristics((const char *)service)); /* LCOV_EXCL_LINE */
- if (ret != BT_ERROR_NONE) //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
- return ret; //LCOV_EXCL_LINE
+ return ret; /* LCOV_EXCL_LINE */
}
int bt_gatt_unwatch_characteristic_changes(bt_gatt_attribute_h service)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- ret = _bt_get_error_code(bluetooth_gatt_unwatch_characteristics((const char *)service)); //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(bluetooth_gatt_unwatch_characteristics((const char *)service)); /* LCOV_EXCL_LINE */
- if (ret != BT_ERROR_NONE) //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
+ if (ret != BT_ERROR_NONE) /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_LINE */
- return ret; //LCOV_EXCL_LINE
+ return ret; /* LCOV_EXCL_LINE */
}
int bt_gatt_get_characteristic_declaration(bt_gatt_attribute_h characteristic,
memset(&property, 0x00, sizeof(bt_gatt_char_property_t));
- ret = _bt_get_error_code(bluetooth_gatt_get_characteristics_property((const char *)characteristic, &property)); //LCOV_EXCL_START
+ ret = _bt_get_error_code(bluetooth_gatt_get_characteristics_property((const char *)characteristic,
+ &property)); /* LCOV_EXCL_START */
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_set_characteristic_value(bt_gatt_attribute_h characteristic,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(value); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(value); /* LCOV_EXCL_START */
if (value_length <= 0)
return BT_ERROR_INVALID_PARAMETER;
ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value((const char *)characteristic,
- (const guint8 *)value, value_length));
+ (const guint8*)value, value_length));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_set_characteristic_value_request(bt_gatt_attribute_h characteristic,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(value); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(value); /* LCOV_EXCL_START */
if (value_length <= 0)
return BT_ERROR_INVALID_PARAMETER;
ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value_request(
(const char *)characteristic,
- (const guint8 *)value, value_length));
+ (const guint8*)value, value_length));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC_LEGACY, callback, characteristic);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC_LEGACY,
+ callback, characteristic);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_clone_attribute_handle(bt_gatt_attribute_h *clone,
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(origin);
- *clone = g_strdup((char *)origin); //LCOV_EXCL_LINE
+ *clone = g_strdup((char *)origin); /* LCOV_EXCL_LINE */
- return error; //LCOV_EXCL_LINE
+ return error; /* LCOV_EXCL_LINE */
}
int bt_gatt_destroy_attribute_handle(bt_gatt_attribute_h handle)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(handle);
- g_free(handle); //LCOV_EXCL_LINE
+ g_free(handle); /* LCOV_EXCL_LINE */
- return error; //LCOV_EXCL_LINE
+ return error; /* LCOV_EXCL_LINE */
}
int bt_gatt_read_characteristic_value(bt_gatt_attribute_h characteristic,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
ret = _bt_get_error_code(bluetooth_gatt_read_characteristic_value((const char *)characteristic));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC_LEGACY, callback, NULL);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC_LEGACY,
+ callback, NULL);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_discover_characteristic_descriptor(bt_gatt_attribute_h characteristic_handle,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic_handle);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
ret = _bt_get_error_code(bluetooth_gatt_discover_characteristic_descriptor
((const char *)characteristic_handle));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED_LEGACY, callback, user_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED_LEGACY,
+ callback, user_data);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
#endif
BT_CHECK_INPUT_PARAMETER(address);
_bt_convert_address_to_hex(&bd_addr, address);
- ret = _bt_get_error_code(bluetooth_connect_le(&bd_addr, auto_connect ? TRUE : FALSE));
+ ret = _bt_get_error_code(bluetooth_connect_le(&bd_addr,
+ auto_connect ? TRUE : FALSE));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
return ret;
}
-int bt_gatt_set_connection_state_changed_cb(bt_gatt_connection_state_changed_cb callback, void *user_data)
+int bt_gatt_set_connection_state_changed_cb(bt_gatt_connection_state_changed_cb callback,
+ void *user_data)
{
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
_bt_unset_cb(BT_EVENT_GATT_CONNECTION_STATUS);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_gatt_get_uuid_specification_name(const char *uuid, char **name)
{
BT_CHECK_GATT_SUPPORT();
offset = 4;
for (i = 0; bt_uuid_name[i].uuid; i++) {
- if (!g_ascii_strncasecmp(uuid + offset, bt_uuid_name[i].uuid, 4)) {
+ if (!g_ascii_strncasecmp(uuid + offset,
+ bt_uuid_name[i].uuid, 4)) {
*name = g_strdup(bt_uuid_name[i].specification_name);
return BT_ERROR_NONE;
}
static void __bt_gatt_free_descriptor(bt_gatt_h gatt_handle)
{
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
g_free(desc->path);
g_free(desc->uuid);
static void __bt_gatt_free_characteristic(bt_gatt_h gatt_handle)
{
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
g_slist_free_full(chr->descriptors, __bt_gatt_free_descriptor);
static void __bt_gatt_free_service(bt_gatt_h gatt_handle)
{
int ret = BT_ERROR_NONE;
- bt_gatt_service_s *svc = (bt_gatt_service_s*)gatt_handle;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)gatt_handle;
g_slist_free_full(svc->included_services, __bt_gatt_free_service);
g_slist_free_full(svc->characteristics, __bt_gatt_free_characteristic);
static void __bt_gatt_destroy_descriptor(bt_gatt_h gatt_handle)
{
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
- bt_gatt_characteristic_s *parent_chr = (bt_gatt_characteristic_s*)desc->parent;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
+ bt_gatt_characteristic_s *parent_chr = (bt_gatt_characteristic_s *)desc->parent;
if (parent_chr)
- parent_chr->descriptors = g_slist_remove(parent_chr->descriptors, desc);
+ parent_chr->descriptors = g_slist_remove(parent_chr->descriptors,
+ desc);
__bt_gatt_free_descriptor(gatt_handle);
}
static void __bt_gatt_destroy_characteristic(bt_gatt_h gatt_handle)
{
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_service_s *parent_svc = (bt_gatt_service_s*)chr->parent;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_service_s *parent_svc = (bt_gatt_service_s *)chr->parent;
if (parent_svc)
- parent_svc->characteristics = g_slist_remove(parent_svc->characteristics, chr);
+ parent_svc->characteristics = g_slist_remove(parent_svc->characteristics,
+ chr);
__bt_gatt_free_characteristic(gatt_handle);
}
static void __bt_gatt_destroy_service(bt_gatt_h gatt_handle)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)gatt_handle;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)gatt_handle;
bt_gatt_server_s *server = NULL;
bt_gatt_client_s *client = NULL;
bt_gatt_service_s *parent_svc = NULL;
if (svc->is_included_service == FALSE) {
if (svc->role == BT_GATT_ROLE_SERVER) {
- server = (bt_gatt_server_s*)svc->parent;
+ server = (bt_gatt_server_s *)svc->parent;
if (server)
- server->services = g_slist_remove(server->services, svc);
+ server->services = g_slist_remove(server->services,
+ svc);
} else {
- client = (bt_gatt_client_s*)svc->parent;
+ client = (bt_gatt_client_s *)svc->parent;
if (client)
- client->services = g_slist_remove(client->services, svc);
+ client->services = g_slist_remove(client->services,
+ svc);
}
} else {
- parent_svc = (bt_gatt_service_s*)svc->parent;
+ parent_svc = (bt_gatt_service_s *)svc->parent;
if (parent_svc)
- parent_svc->included_services = g_slist_remove(parent_svc->included_services, svc);
+ parent_svc->included_services = g_slist_remove(parent_svc->included_services,
+ svc);
}
__bt_gatt_free_service(gatt_handle);
i = (1 << (size - 1)) + (i & ((1 << (size - 1)) - 1));
return i;
- }
+}
static int __convert_unsigned_to_signed(int value, int size)
{
if ((value & (1 << (size-1))) != 0) {
- value = -1 * ((1 << (size-1)) - (value & ((1 << (size-1)) - 1)));
+ value = -1 * ((1 << (size-1))
+ - (value & ((1 << (size-1)) - 1)));
}
return value;
}
static int __convert_unsigned_bytes_to_int16(char b0, char b1)
{
- return (__convert_unsigned_byte_to_int(b0) + (__convert_unsigned_byte_to_int(b1) << 8));
+ return (__convert_unsigned_byte_to_int(b0)
+ + (__convert_unsigned_byte_to_int(b1) << 8));
}
static int __convert_unsigned_bytes_to_int32(char b0, char b1, char b2, char b3)
{
- return (__convert_unsigned_byte_to_int(b0) + (__convert_unsigned_byte_to_int(b1) << 8))
- + (__convert_unsigned_byte_to_int(b2) << 16) + (__convert_unsigned_byte_to_int(b3) << 24);
+ return (__convert_unsigned_byte_to_int(b0)
+ + (__convert_unsigned_byte_to_int(b1) << 8))
+ + (__convert_unsigned_byte_to_int(b2) << 16)
+ + (__convert_unsigned_byte_to_int(b3) << 24);
}
static double power(int x, int n)
{
- /* pow() cannot not referenced. */
- if(n == 0)
- return 1;
- else
- return x*power(x,n-1);
+ /* pow() cannot not referenced. */
+ if (n == 0)
+ return 1;
+ else
+ return x*power(x, n-1);
}
static float __convert_bytes_to_short_float(char b0, char b1)
int mantissa;
float exponent;
mantissa = __convert_unsigned_to_signed(__convert_unsigned_byte_to_int(b0)
- + (__convert_unsigned_byte_to_int(b1) << 8)
- + (__convert_unsigned_byte_to_int(b2) << 16), 24);
+ + (__convert_unsigned_byte_to_int(b1) << 8)
+ + (__convert_unsigned_byte_to_int(b2) << 16), 24);
exponent = power(10, b3);
return (float)(mantissa * exponent);
default:
return 0;
}
- }
+}
static int __get_data_type_int_size(bt_data_type_int_e format)
{
default:
return 0;
}
- }
+}
int bt_gatt_destroy(bt_gatt_h gatt_handle)
{
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
+
int bt_gatt_get_value(bt_gatt_h gatt_handle, char **value, int *value_length)
{
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(value); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(value); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(value_length);
if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) {
return BT_ERROR_INVALID_PARAMETER;
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-int bt_gatt_get_int_value(bt_gatt_h gatt_handle, bt_data_type_int_e type, int offset, int *value)
+int bt_gatt_get_int_value(bt_gatt_h gatt_handle, bt_data_type_int_e type,
+ int offset, int *value)
{
char *val;
int val_len;
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(value); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(value); /* LCOV_EXCL_START */
if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) {
val = chr->value;
*value = __convert_unsigned_byte_to_int(val[offset]);
break;
case BT_DATA_TYPE_UINT16:
- *value = __convert_unsigned_bytes_to_int16(val[offset], val[offset+1]);
+ *value = __convert_unsigned_bytes_to_int16(val[offset],
+ val[offset+1]);
break;
case BT_DATA_TYPE_UINT32:
- *value = __convert_unsigned_bytes_to_int32(val[offset], val[offset+1],
- val[offset+2], val[offset+3]);
+ *value = __convert_unsigned_bytes_to_int32(val[offset],
+ val[offset+1], val[offset+2], val[offset+3]);
break;
case BT_DATA_TYPE_SINT8:
*value = __convert_unsigned_to_signed(__convert_unsigned_byte_to_int(val[offset]), 8);
case BT_DATA_TYPE_SINT16:
*value = __convert_unsigned_to_signed(__convert_unsigned_bytes_to_int16(val[offset],
- val[offset+1]), 16);
+ val[offset+1]), 16);
break;
case BT_DATA_TYPE_SINT32:
*value = __convert_unsigned_to_signed(__convert_unsigned_bytes_to_int32(val[offset],
- val[offset+1], val[offset+2], val[offset+3]), 32);
+ val[offset+1], val[offset+2], val[offset+3]), 32);
break;
default:
return BT_ERROR_INVALID_PARAMETER;
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-int bt_gatt_get_float_value(bt_gatt_h gatt_handle, bt_data_type_float_e type, int offset, float *value)
+int bt_gatt_get_float_value(bt_gatt_h gatt_handle, bt_data_type_float_e type,
+ int offset, float *value)
{
char *val;
int val_len;
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(value); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(value); /* LCOV_EXCL_START */
if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) {
val = chr->value;
switch (type) {
case BT_DATA_TYPE_SFLOAT:
- *value = __convert_bytes_to_short_float(val[offset], val[offset+1]);
+ *value = __convert_bytes_to_short_float(val[offset],
+ val[offset+1]);
break;
case BT_DATA_TYPE_FLOAT:
- *value = __convert_bytes_to_float(val[offset], val[offset+1],
- val[offset+2], val[offset+3]);
+ *value = __convert_bytes_to_float(val[offset],
+ val[offset+1], val[offset+2], val[offset+3]);
break;
default:
return BT_ERROR_INVALID_PARAMETER;
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-int bt_gatt_set_value(bt_gatt_h gatt_handle, const char *value, int value_length)
+int bt_gatt_set_value(bt_gatt_h gatt_handle, const char *value,
+ int value_length)
{
int ret;
char **val = NULL;
int *val_len = NULL;
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(value); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(value); /* LCOV_EXCL_START */
if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) {
val = &chr->value;
}
if (handle->role == BT_GATT_ROLE_SERVER && handle->path) {
- ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path, value, value_length));
+ ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path,
+ value, value_length));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
return ret;
*val = g_memdup(value, value_length);
*val_len = value_length;
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-int bt_gatt_set_int_value(bt_gatt_h gatt_handle, bt_data_type_int_e type, int value, int offset)
+int bt_gatt_set_int_value(bt_gatt_h gatt_handle, bt_data_type_int_e type,
+ int value, int offset)
{
int ret;
char **val = NULL;
char *tmp;
int fmt_size;
int idx = offset;
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) { //LCOV_EXCL_START
+ if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) { /* LCOV_EXCL_START */
val = &chr->value;
val_len = &chr->value_length;
} else if (handle->type == BT_GATT_TYPE_DESCRIPTOR) {
if (*val == NULL) {
*val = g_malloc0(fmt_size);
*val_len = fmt_size;
- } else if (*val_len == offset) {// Added
+ } else if (*val_len == offset) { /* Added */
tmp = g_malloc0(*val_len + fmt_size);
/* Fix : NULL_RETURNS */
if (!tmp) {
g_free(*val);
*val = tmp;
*val_len += fmt_size;
- } else if (*val_len < offset + fmt_size) {// Overlapped
+ } else if (*val_len < offset + fmt_size) {/* Overlapped */
tmp = g_malloc0(offset + fmt_size);
/* Fix : NULL_RETURNS */
if (!tmp) {
}
if (handle->role == BT_GATT_ROLE_SERVER && handle->path) {
- ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path, *val, *val_len));
+ ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path,
+ *val, *val_len));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
return ret;
}
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_gatt_set_float_value(bt_gatt_h gatt_handle, bt_data_type_float_e type,
char *tmp;
int fmt_size;
int idx = offset;
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) { //LCOV_EXCL_START
+ if (handle->type == BT_GATT_TYPE_CHARACTERISTIC) { /* LCOV_EXCL_START */
val = &chr->value;
val_len = &chr->value_length;
} else if (handle->type == BT_GATT_TYPE_DESCRIPTOR) {
if (*val == NULL)
return BT_ERROR_OUT_OF_MEMORY;
*val_len = fmt_size;
- } else if (*val_len == offset) {// Added
+ } else if (*val_len == offset) {/* Added */
tmp = g_malloc0(*val_len + fmt_size);
/* Fix : NULL_RETURNS */
if (tmp == NULL) {
g_free(*val);
*val = tmp;
*val_len += fmt_size;
- } else if (*val_len < offset + fmt_size) {// Overlapped
+ } else if (*val_len < offset + fmt_size) {/* Overlapped */
tmp = g_malloc0(offset + fmt_size);
/* Fix : NULL_RETURNS */
if (tmp == NULL) {
}
if (handle->role == BT_GATT_ROLE_SERVER && handle->path) {
- ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path, *val, *val_len));
+ ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path,
+ *val, *val_len));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
return ret;
}
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_gatt_get_permissions(bt_gatt_h gatt_handle, int *permissions)
{
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
int bt_gatt_set_permissions(bt_gatt_h gatt_handle, int permissions)
{
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
- bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
+ bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_gatt_get_uuid(bt_gatt_h gatt_handle, char **uuid)
{
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(uuid); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_LINE */
- *uuid = g_strdup(handle->uuid); //LCOV_EXCL_LINE
+ *uuid = g_strdup(handle->uuid); /* LCOV_EXCL_LINE */
- return BT_ERROR_NONE; //LCOV_EXCL_LINE
+ return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
int bt_gatt_get_type(bt_gatt_h gatt_handle, bt_gatt_type_e *gatt_type)
{
- bt_gatt_common_s *handle = (bt_gatt_common_s*)gatt_handle;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)gatt_handle;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(gatt_type); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(gatt_type); /* LCOV_EXCL_LINE */
- *gatt_type = handle->type; //LCOV_EXCL_LINE
+ *gatt_type = handle->type; /* LCOV_EXCL_LINE */
- return BT_ERROR_NONE; //LCOV_EXCL_LINE
+ return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_gatt_service_create(const char *uuid, bt_gatt_service_type_e type,
bt_gatt_h *service)
{
BT_CHECK_INPUT_PARAMETER(uuid);
BT_CHECK_INPUT_PARAMETER(service);
- svc = (bt_gatt_service_s*)g_malloc0(sizeof(bt_gatt_service_s));
+ svc = (bt_gatt_service_s *)g_malloc0(sizeof(bt_gatt_service_s));
if (svc == NULL)
return BT_ERROR_OUT_OF_MEMORY;
svc->type = BT_GATT_TYPE_SERVICE;
int bt_gatt_service_add_characteristic(bt_gatt_h service,
bt_gatt_h characteristic)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)characteristic;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
int bt_gatt_service_add_included_service(bt_gatt_h service,
bt_gatt_h included_service)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
- bt_gatt_service_s *included_svc = (bt_gatt_service_s*)included_service;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
+ bt_gatt_service_s *included_svc = (bt_gatt_service_s *)included_service;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
return BT_ERROR_INVALID_PARAMETER;
}
- svc->included_services = g_slist_append(svc->included_services, included_svc);
+ svc->included_services = g_slist_append(svc->included_services,
+ included_svc);
included_svc->parent = (void *)service;
return BT_ERROR_NONE;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_gatt_service_get_client(bt_gatt_h service, bt_gatt_client_h *client)
{
bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(client); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(client); /* LCOV_EXCL_START */
if (svc->is_included_service) {
BT_ERR("This is included service of %p", svc->parent);
*client = (bt_gatt_client_h)svc->parent;
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_gatt_service_get_characteristic(bt_gatt_h service, const char *uuid,
bt_gatt_h *characteristic)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
bt_gatt_h gatt_handle = NULL;
int ret;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(uuid); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(characteristic);
- ret = __get_gatt_handle_by_uuid(svc->characteristics, uuid, &gatt_handle);
+ ret = __get_gatt_handle_by_uuid(svc->characteristics,
+ uuid, &gatt_handle);
if (ret == BT_ERROR_NONE && gatt_handle != NULL) {
*characteristic = gatt_handle;
return BT_ERROR_NONE;
}
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_STOP
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_STOP */
return ret;
}
int bt_gatt_service_foreach_characteristics(bt_gatt_h service,
- bt_gatt_foreach_cb callback, void *user_data)
+ bt_gatt_foreach_cb callback, void *user_data)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
bt_gatt_characteristic_s *chr = NULL;
GSList *l = NULL;
int total = 0;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
total = g_slist_length(svc->characteristics);
break;
}
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_gatt_service_get_included_service(bt_gatt_h service, const char *uuid,
bt_gatt_h *included_service)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
bt_gatt_h gatt_handle = NULL;
int ret;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(uuid); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(included_service);
- ret = __get_gatt_handle_by_uuid(svc->included_services, uuid, &gatt_handle);
+ ret = __get_gatt_handle_by_uuid(svc->included_services,
+ uuid, &gatt_handle);
if (ret == BT_ERROR_NONE && gatt_handle != NULL) {
*included_service = gatt_handle;
return BT_ERROR_NONE;
}
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_STOP
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
+ ret); /* LCOV_EXCL_STOP */
return ret;
}
int bt_gatt_service_foreach_included_services(bt_gatt_h service,
- bt_gatt_foreach_cb callback, void *user_data)
+ bt_gatt_foreach_cb callback, void *user_data)
{
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
bt_gatt_service_s *included_svc = NULL;
GSList *l = NULL;
int total = 0;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(service);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_LINE */
- total = g_slist_length(svc->included_services); //LCOV_EXCL_LINE
+ total = g_slist_length(svc->included_services); /* LCOV_EXCL_LINE */
for (l = svc->included_services; l; l = g_slist_next(l)) {
- included_svc = l->data; //LCOV_EXCL_LINE
- if (!callback(total, index++, (bt_gatt_h)included_svc, user_data)) //LCOV_EXCL_LINE
+ included_svc = l->data; /* LCOV_EXCL_LINE */
+ if (!callback(total, index++, (bt_gatt_h)included_svc,
+ user_data)) /* LCOV_EXCL_LINE */
break;
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_gatt_characteristic_create(const char *uuid, int permissions,
- int properties, const char *value, int value_length,
- bt_gatt_h *characteristic)
+ int properties, const char *value,
+ int value_length, bt_gatt_h *characteristic)
{
int ret = BT_ERROR_NONE;
bt_gatt_characteristic_s *chr = NULL;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_gatt_characteristic_get_service(bt_gatt_h characteristic, bt_gatt_h *service)
{
bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(service); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(service); /* LCOV_EXCL_LINE */
- *service = (bt_gatt_h)chr->parent; //LCOV_EXCL_LINE
+ *service = (bt_gatt_h)chr->parent; /* LCOV_EXCL_LINE */
- return BT_ERROR_NONE; //LCOV_EXCL_LINE
+ return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
int bt_gatt_characteristic_get_properties(bt_gatt_h characteristic, int *properties)
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(properties); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(properties); /* LCOV_EXCL_START */
if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) {
BT_ERR("Wrong type of GATT handle : %d", chr->type);
*properties = chr->properties;
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
-int bt_gatt_characteristic_set_properties(bt_gatt_h characteristic, int properties)
+int bt_gatt_characteristic_set_properties(bt_gatt_h characteristic,
+ int properties)
{
bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
BT_CHECK_INPUT_PARAMETER(characteristic);
if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) {
- BT_ERR("Wrong type of GATT handle : %d", chr->type); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Wrong type of GATT handle : %d",
+ chr->type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
- chr->properties = properties; //LCOV_EXCL_LINE
+ chr->properties = properties; /* LCOV_EXCL_LINE */
- return BT_ERROR_NONE; //LCOV_EXCL_LINE
+ return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
int bt_gatt_characteristic_get_write_type(bt_gatt_h characteristic,
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(write_type); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(write_type); /* LCOV_EXCL_LINE */
- if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) { //LCOV_EXCL_LINE
- BT_ERR("Wrong type of GATT handle : %d", chr->type); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) { /* LCOV_EXCL_LINE */
+ BT_ERR("Wrong type of GATT handle : %d",
+ chr->type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
- *write_type = chr->write_type; //LCOV_EXCL_LINE
+ *write_type = chr->write_type; /* LCOV_EXCL_LINE */
- return BT_ERROR_NONE; //LCOV_EXCL_LINE
+ return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
}
int bt_gatt_characteristic_set_write_type(bt_gatt_h characteristic,
BT_CHECK_INPUT_PARAMETER(characteristic);
if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) {
- BT_ERR("Wrong type of GATT handle : %d", chr->type); //LCOV_EXCL_LINE
- return BT_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
+ BT_ERR("Wrong type of GATT handle : %d", chr->type); /* LCOV_EXCL_LINE */
+ return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
}
chr->write_type = write_type;
return BT_ERROR_NONE;
}
-int bt_gatt_characteristic_get_descriptor(bt_gatt_h characteristic, const char *uuid,
- bt_gatt_h *descriptor)
+int bt_gatt_characteristic_get_descriptor(bt_gatt_h characteristic,
+ const char *uuid, bt_gatt_h *descriptor)
{
bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
bt_gatt_h gatt_handle = NULL;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(uuid); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(uuid); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(descriptor);
ret = __get_gatt_handle_by_uuid(chr->descriptors, uuid, &gatt_handle);
}
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_characteristic_foreach_descriptors(bt_gatt_h characteristic,
- bt_gatt_foreach_cb callback, void *user_data)
+ bt_gatt_foreach_cb callback, void *user_data)
{
GSList *l;
bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(characteristic);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
if (chr->type != BT_GATT_TYPE_CHARACTERISTIC) {
BT_ERR("Wrong type of GATT handle : %d", chr->type);
i = 1;
for (l = chr->descriptors; l; l = g_slist_next(l)) {
if (!callback(total, i++, (bt_gatt_h)l->data, user_data))
- break; //LCOV_EXCL_STOP
+ break; /* LCOV_EXCL_STOP */
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_gatt_descriptor_create(const char *uuid, int permissions,
const char *value, int value_length,
bt_gatt_h *descriptor)
return ret;
}
-//LCOV_EXCL_STOP
-int bt_gatt_descriptor_get_characteristic(bt_gatt_h descriptor, bt_gatt_h *characteristic)
+/* LCOV_EXCL_STOP */
+int bt_gatt_descriptor_get_characteristic(bt_gatt_h descriptor,
+ bt_gatt_h *characteristic)
{
bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)descriptor;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_gatt_server_initialize(void)
{
BT_CHECK_INIT_STATUS();
GSList *l;
for (l = gatt_server_list; l; l = g_slist_next(l)) {
bt_gatt_server_s *serv = l->data;
- g_slist_free_full(serv->services, __bt_gatt_free_service);
+ g_slist_free_full(serv->services,
+ __bt_gatt_free_service);
g_free(serv);
}
g_slist_free(gatt_server_list);
int bt_gatt_server_destroy(bt_gatt_server_h server)
{
- bt_gatt_server_s *serv = (bt_gatt_server_s*)server;
+ bt_gatt_server_s *serv = (bt_gatt_server_s *)server;
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(server);
bt_gatt_server_read_value_requested_cb callback,
void *user_data)
{
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
BT_CHECK_INIT_STATUS();
BT_CHECK_GATT_SERVER_INIT_STATUS();
}
int bt_gatt_server_set_notification_state_change_cb(bt_gatt_h gatt_handle,
- bt_gatt_server_notification_state_change_cb callback,
- void *user_data)
+ bt_gatt_server_notification_state_change_cb callback,
+ void *user_data)
{
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)gatt_handle;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
BT_CHECK_INIT_STATUS();
BT_CHECK_GATT_SERVER_INIT_STATUS();
int bt_gatt_server_register_service(bt_gatt_server_h server, bt_gatt_h service)
{
int ret = BT_ERROR_NONE;
- bt_gatt_server_s *serv = (bt_gatt_server_s*)server;
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
+ bt_gatt_server_s *serv = (bt_gatt_server_s *)server;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
GSList *char_l;
BT_CHECK_INIT_STATUS();
return BT_ERROR_ALREADY_DONE;
}
- ret = _bt_get_error_code(bluetooth_gatt_add_service(svc->uuid, &svc->path));
+ ret = _bt_get_error_code(bluetooth_gatt_add_service(svc->uuid,
+ &svc->path));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
GSList *desc_l;
bt_gatt_characteristic_s *chr = char_l->data;
- ret = _bt_get_error_code(bluetooth_gatt_add_new_characteristic(svc->path, chr->uuid,
- (bt_gatt_characteristic_property_t)chr->properties, &chr->path));
+ ret = _bt_get_error_code(bluetooth_gatt_add_new_characteristic(svc->path,
+ chr->uuid,
+ (bt_gatt_characteristic_property_t)chr->properties,
+ &chr->path));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
goto fail;
}
ret = _bt_get_error_code(bluetooth_gatt_set_characteristic_value(chr->path,
- chr->value, chr->value_length));
+ chr->value, chr->value_length));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
goto fail;
}
for (desc_l = chr->descriptors; desc_l; desc_l = g_slist_next(desc_l)) {
bt_gatt_descriptor_s *desc = desc_l->data;
- ret = _bt_get_error_code(bluetooth_gatt_add_descriptor(chr->path, desc->uuid, &desc->path));
+ ret = _bt_get_error_code(bluetooth_gatt_add_descriptor(chr->path,
+ desc->uuid, &desc->path));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
goto fail;
}
- ret = _bt_get_error_code(bluetooth_gatt_set_descriptor_value(desc->path, desc->value, desc->value_length));
+ ret = _bt_get_error_code(bluetooth_gatt_set_descriptor_value(desc->path,
+ desc->value, desc->value_length));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
goto fail;
}
}
return ret;
}
-int bt_gatt_server_unregister_service(bt_gatt_server_h server, bt_gatt_h service)
+int bt_gatt_server_unregister_service(bt_gatt_server_h server,
+ bt_gatt_h service)
{
- bt_gatt_server_s *serv = (bt_gatt_server_s*)server;
- bt_gatt_service_s *svc = (bt_gatt_service_s*)service;
+ bt_gatt_server_s *serv = (bt_gatt_server_s *)server;
+ bt_gatt_service_s *svc = (bt_gatt_service_s *)service;
BT_CHECK_INIT_STATUS();
BT_CHECK_GATT_SERVER_INIT_STATUS();
int bt_gatt_server_unregister_all_services(bt_gatt_server_h server)
{
- bt_gatt_server_s *serv = (bt_gatt_server_s*)server;
+ bt_gatt_server_s *serv = (bt_gatt_server_s *)server;
BT_CHECK_INIT_STATUS();
BT_CHECK_GATT_SERVER_INIT_STATUS();
* once the new parameters available to CAPI API, the below
* code be made generic for both read and write */
ret = _bt_get_error_code(bluetooth_gatt_send_response(request_id,
- BLUETOOTH_GATT_ATT_REQUEST_TYPE_READ, BT_ERROR_NONE,
- offset, value, value_length));
+ BLUETOOTH_GATT_ATT_REQUEST_TYPE_READ,
+ BT_ERROR_NONE,
+ offset, value, value_length));
if (ret != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
bt_gatt_server_notification_sent_cb callback,
const char *device_address, void *user_data)
{
- bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s*)characteristic;
- bt_gatt_common_s *handle = (bt_gatt_common_s*)characteristic;
+ bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)characteristic;
+ bt_gatt_common_s *handle = (bt_gatt_common_s *)characteristic;
bluetooth_device_address_t addr_hex = { {0,} };
int ret = BT_ERROR_NONE;
if (chr->value_length > 0 && chr->value) {
if (handle->role == BT_GATT_ROLE_SERVER && handle->path) {
- ret = bluetooth_gatt_server_set_notification(handle->path, &addr_hex);
+ ret = bluetooth_gatt_server_set_notification(handle->path,
+ &addr_hex);
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
return ret;
}
- ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(handle->path, chr->value, chr->value_length));
+ ret = _bt_get_error_code(bluetooth_gatt_update_characteristic(
+ handle->path,
+ chr->value,
+ chr->value_length));
if (ret != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
return ret;
}
}
BT_CHECK_INPUT_PARAMETER(uuid);
BT_CHECK_INPUT_PARAMETER(service);
- ret = __get_gatt_handle_by_uuid(server_s->services, uuid, &gatt_handle);
+ ret = __get_gatt_handle_by_uuid(server_s->services,
+ uuid, &gatt_handle);
if (ret == BT_ERROR_NONE && gatt_handle != NULL) {
*service = gatt_handle;
return BT_ERROR_NONE;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_gatt_client_create(const char *remote_address, bt_gatt_client_h *client)
{
int ret = BT_ERROR_NONE;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(remote_address); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(remote_address); /* LCOV_EXCL_START */
for (l = gatt_client_list; l; l = g_slist_next(gatt_client_list)) {
bt_gatt_client_s *c = (bt_gatt_client_s *)l->data;
if (_bt_gatt_client_update_all(*client) == BT_ERROR_NONE)
client_s->services_discovered = true;
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_client_destroy(bt_gatt_client_h client)
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(client); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(client); /* LCOV_EXCL_START */
g_free(client_s->remote_address);
g_slist_free_full(client_s->services, __bt_gatt_free_service);
gatt_client_list = g_slist_remove(gatt_client_list, client_s);
g_free(client_s);
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_gatt_client_get_remote_address(bt_gatt_client_h client,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(client); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(client); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(remote_address);
*remote_address = g_strdup(client_s->remote_address);
return true;
}
- return false; //LCOV_EXCL_STOP
+ return false; /* LCOV_EXCL_STOP */
}
int bt_gatt_client_read_value(bt_gatt_h gatt_handle,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
if (__bt_gatt_client_is_in_progress()) {
BT_ERR("Operation is in progress");
if (c->type == BT_GATT_TYPE_CHARACTERISTIC) {
bt_gatt_characteristic_s *chr = (bt_gatt_characteristic_s *)gatt_handle;
- ret = _bt_get_error_code(bluetooth_gatt_read_characteristic_value(chr->path));
+ ret = _bt_get_error_code(
+ bluetooth_gatt_read_characteristic_value(chr->path));
if (ret != BT_ERROR_NONE) {
g_free(cb_data);
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC, callback, cb_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_READ_CHARACTERISTIC,
+ callback, cb_data);
}
} else if (c->type == BT_GATT_TYPE_DESCRIPTOR) {
bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
- ret = _bt_get_error_code(bluetooth_gatt_read_descriptor_value(desc->path));
+ ret = _bt_get_error_code(
+ bluetooth_gatt_read_descriptor_value(desc->path));
if (ret != BT_ERROR_NONE) {
g_free(cb_data);
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_READ_DESCRIPTOR, callback, cb_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_READ_DESCRIPTOR,
+ callback, cb_data);
}
} else {
BT_ERR("Invalid handle type for read ");
g_free(cb_data);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_client_write_value(bt_gatt_h gatt_handle,
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(gatt_handle);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_START */
if (__bt_gatt_client_is_in_progress()) {
BT_ERR("Operation is in progress");
BT_DBG("path : %s", chr->path);
if (chr->write_type == BT_GATT_WRITE_TYPE_WRITE)
ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value_by_type(
- chr->path, (guint8 *)chr->value, chr->value_length,
+ chr->path, (guint8 *)chr->value,
+ chr->value_length,
BT_GATT_PROPERTY_WRITE));
else if (chr->write_type == BT_GATT_WRITE_TYPE_WRITE_NO_RESPONSE)
ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value_by_type(
- chr->path, (guint8 *)chr->value, chr->value_length,
+ chr->path, (guint8 *)chr->value,
+ chr->value_length,
BT_GATT_PROPERTY_WRITE_WITHOUT_RESPONSE));
else {
BT_ERR("Unknow write type : %d", chr->write_type);
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
} else {
if (chr->write_type != BT_GATT_WRITE_TYPE_WRITE_NO_RESPONSE)
- _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC, callback, cb_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_CHARACTERISTIC,
+ callback, cb_data);
}
} else if (c->type == BT_GATT_TYPE_DESCRIPTOR) {
bt_gatt_descriptor_s *desc = (bt_gatt_descriptor_s *)gatt_handle;
- ret = _bt_get_error_code(bluetooth_gatt_write_descriptor_value(desc->path,
- (guint8 *)desc->value, desc->value_length));
+ ret = _bt_get_error_code(bluetooth_gatt_write_descriptor_value(
+ desc->path,
+ (guint8 *)desc->value,
+ desc->value_length));
if (ret != BT_ERROR_NONE) {
g_free(cb_data);
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
} else {
- _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_DESCRIPTOR, callback, cb_data);
+ _bt_set_cb(BT_EVENT_GATT_CLIENT_WRITE_DESCRIPTOR,
+ callback, cb_data);
}
} else {
BT_ERR("Invalid handle type for write ");
}
}
}
-} //LCOV_EXCL_STOP
+} /* LCOV_EXCL_STOP */
int bt_gatt_client_set_characteristic_value_changed_cb(bt_gatt_h characteristic,
bt_gatt_client_characteristic_value_changed_cb callback,
ret = _bt_get_error_code(bluetooth_gatt_watch_characteristics(
chr->path));
if (ret != BT_ERROR_NONE)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
else
_bt_set_cb(BT_EVENT_GATT_CLIENT_VALUE_CHANGED,
__value_changed_cb, NULL);
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(characteristic); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(characteristic); /* LCOV_EXCL_START */
if (chr->properties &
(BT_GATT_PROPERTY_NOTIFY | BT_GATT_PROPERTY_INDICATE)) {
- ret = _bt_get_error_code(bluetooth_gatt_unwatch_characteristics(
- chr->path));
+ ret = _bt_get_error_code(
+ bluetooth_gatt_unwatch_characteristics(chr->path));
if (ret != BT_ERROR_NONE)
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+ BT_ERR("%s(0x%08x)",
+ _bt_convert_error_to_string(ret), ret);
else {
chr->value_changed_cb = NULL;
chr->value_changed_user_data = NULL;
ret = BT_ERROR_NOT_SUPPORTED;
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_gatt_client_get_service(bt_gatt_client_h client, const char *uuid,
}
int bt_gatt_client_foreach_services(bt_gatt_client_h client,
- bt_gatt_foreach_cb callback, void *user_data)
+ bt_gatt_foreach_cb callback,
+ void *user_data)
{
bt_gatt_client_s *client_s = (bt_gatt_client_s *)client;
GSList *l = NULL;
BT_CHECK_GATT_SUPPORT();
BT_CHECK_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(client);
- BT_CHECK_INPUT_PARAMETER(callback); //LCOV_EXCL_LINE
+ BT_CHECK_INPUT_PARAMETER(callback); /* LCOV_EXCL_LINE */
- total = g_slist_length(client_s->services); //LCOV_EXCL_LINE
+ total = g_slist_length(client_s->services); /* LCOV_EXCL_LINE */
- for (l = client_s->services; l; l = g_slist_next(l)) { //LCOV_EXCL_LINE
- if (!callback(total, index++, (bt_gatt_h)l->data, user_data)) //LCOV_EXCL_LINE
+ for (l = client_s->services; l; l = g_slist_next(l)) { /* LCOV_EXCL_LINE */
+ if (!callback(total, index++,
+ (bt_gatt_h)l->data, user_data)) /* LCOV_EXCL_LINE */
break;
}
error = bluetooth_hdp_activate(data_type, HDP_ROLE_SINK, HDP_QOS_ANY, &app_handle);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
return error;
}
error = bluetooth_hdp_deactivate(app_id);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
}
return error;
}
BT_CHECK_HDP_SUPPORT();
BT_CHECK_INIT_STATUS();
- if (NULL == data || 0 >= size) { //LCOV_EXCL_START
+ if (NULL == data || 0 >= size) { /* LCOV_EXCL_START */
BT_ERR("%s", _bt_convert_error_to_string(BT_ERROR_INVALID_PARAMETER));
}
error = bluetooth_hdp_send_data(channel, data, size);
if (BT_ERROR_NONE != error) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
int bt_hdp_connect_to_source(const char *remote_address, const char *app_id)
BT_CHECK_HDP_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_INPUT_PARAMETER(app_id); //LCOV_EXCL_START
+ BT_CHECK_INPUT_PARAMETER(app_id); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(remote_address);
_bt_convert_address_to_hex(&addr_hex, remote_address);
error = bluetooth_hdp_connect(app_id, HDP_QOS_ANY, &addr_hex);
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
int bt_hdp_disconnect(const char *remote_address, unsigned int channel)
bluetooth_device_address_t addr_hex = { {0,} };
BT_CHECK_HDP_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(remote_address);
_bt_convert_address_to_hex(&addr_hex, remote_address);
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
int bt_hdp_set_connection_state_changed_cb(bt_hdp_connected_cb connected_cb,
{
BT_CHECK_HDP_SUPPORT();
BT_CHECK_INIT_STATUS();
- if ( _bt_check_cb(BT_EVENT_HDP_CONNECTED) == true)
+ if (_bt_check_cb(BT_EVENT_HDP_CONNECTED) == true)
_bt_unset_cb(BT_EVENT_HDP_CONNECTED);
- if ( _bt_check_cb(BT_EVENT_HDP_DISCONNECTED) == true)
+ if (_bt_check_cb(BT_EVENT_HDP_DISCONNECTED) == true)
_bt_unset_cb(BT_EVENT_HDP_DISCONNECTED);
return BT_ERROR_NONE;
{
BT_CHECK_HDP_SUPPORT();
BT_CHECK_INIT_STATUS();
- if ( _bt_check_cb(BT_EVENT_HDP_DATA_RECEIVED) == true)
+ if (_bt_check_cb(BT_EVENT_HDP_DATA_RECEIVED) == true)
_bt_unset_cb(BT_EVENT_HDP_DATA_RECEIVED);
return BT_ERROR_NONE;
}
#ifdef TIZEN_HID_DEVICE_DISABLE
#define BT_CHECK_HID_DEVICE_SUPPORT() \
- { \
- BT_CHECK_BT_SUPPORT(); \
- LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_SUPPORTED); \
- return BT_ERROR_NOT_SUPPORTED; \
- }
+ { \
+ BT_CHECK_BT_SUPPORT(); \
+ LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_SUPPORTED); \
+ return BT_ERROR_NOT_SUPPORTED; \
+ }
#else
#define BT_CHECK_HID_DEVICE_SUPPORT()
#endif
#define BT_CHECK_HID_HOST_INIT_STATUS() \
- if (__bt_check_hid_host_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
+ if (__bt_check_hid_host_init_status() == BT_ERROR_NOT_INITIALIZED) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
error = bluetooth_hid_init(_bt_hid_event_proxy, user_data);
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
- return error; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
+ return error; /* LCOV_EXCL_LINE */
}
_bt_set_cb(BT_EVENT_HID_CONNECTION_STATUS, connection_cb, user_data);
error = bluetooth_hid_deinit();
error = _bt_get_error_code(error);
if (BT_ERROR_NONE != error) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); //LCOV_EXCL_LINE
- return error; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); /* LCOV_EXCL_LINE */
+ return error; /* LCOV_EXCL_LINE */
}
_bt_unset_cb(BT_EVENT_HID_CONNECTION_STATUS);
bluetooth_device_address_t addr_hex = { {0,} };
BT_CHECK_HID_HOST_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_HID_HOST_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
int bt_hid_host_disconnect(const char *remote_address)
bluetooth_device_address_t addr_hex = { {0,} };
BT_CHECK_HID_HOST_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_HID_HOST_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
if (error != BT_ERROR_NONE) {
BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
}
- return error; //LCOV_EXCL_STOP
+ return error; /* LCOV_EXCL_STOP */
}
-//LCOV_EXCL_START
-int bt_hid_device_activate(bt_hid_device_connection_state_changed_cb callback, void * user_data)
+/* LCOV_EXCL_START */
+int bt_hid_device_activate(bt_hid_device_connection_state_changed_cb callback, void *user_data)
{
int error;
BT_CHECK_HID_DEVICE_SUPPORT();
BT_CHECK_INPUT_PARAMETER(mouse_data);
ret = bluetooth_hid_device_send_mouse_event(remote_address,
- *(hid_send_mouse_event_t*)mouse_data);
+ *(hid_send_mouse_event_t *)mouse_data);
if (ret <= 0) {
if (ret == -1) {
/* write fail case */
BT_CHECK_INPUT_PARAMETER(key_data);
ret = bluetooth_hid_device_send_key_event(remote_address,
- *(hid_send_key_event_t*)key_data);
+ *(hid_send_key_event_t *)key_data);
if (ret <= 0) {
if (ret == -1) {
/* write fail case */
_bt_unset_cb(BT_EVENT_HID_DEVICE_DATA_RECEIVED);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
#endif
#define BT_CHECK_IPSP_INIT_STATUS() \
- if (__bt_check_ipsp_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
+ if (__bt_check_ipsp_init_status() == BT_ERROR_NOT_INITIALIZED) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int __bt_check_ipsp_init_status(void)
{
if (is_ipsp_initialized != true) {
_bt_unset_cb(BT_EVENT_IPSP_CONNECTION_STATUS);
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
#endif
#define BT_CHECK_OPP_CLIENT_INIT_STATUS() \
- if (__bt_check_opp_client_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
+ if (__bt_check_opp_client_init_status() == BT_ERROR_NOT_INITIALIZED) { \
LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
-char** __bt_opp_get_file_array(GList *file_list)
+/* LCOV_EXCL_START */
+char **__bt_opp_get_file_array(GList *file_list)
{
char **files = NULL;
char *c_file = NULL;
BT_DBG("file: %s", files[i]);
return files;
-} //LCOV_EXCL_STOP
+} /* LCOV_EXCL_STOP */
int bt_opp_client_initialize(void)
{
error_code = _bt_get_error_code(bluetooth_opc_init());
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
- error_code); //LCOV_EXCL_LINE
- return error_code; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
+ error_code); /* LCOV_EXCL_LINE */
+ return error_code; /* LCOV_EXCL_LINE */
}
is_opp_client_initialized = true;
bt_opp_client_clear_files();
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
- error_code); //LCOV_EXCL_LINE
- return error_code; //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
+ error_code); /* LCOV_EXCL_LINE */
+ return error_code; /* LCOV_EXCL_LINE */
}
is_opp_client_initialized = false;
BT_CHECK_INIT_STATUS();
BT_CHECK_OPP_CLIENT_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(file);
- BT_CHECK_ADAPTER_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_ADAPTER_STATUS(); /* LCOV_EXCL_START */
if (access(file, F_OK) == 0) {
sending_files = g_list_append(sending_files, strdup(file));
error_code);
}
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
int bt_opp_client_clear_files(void)
BT_CHECK_OPP_CLIENT_INIT_STATUS();
BT_CHECK_ADAPTER_STATUS();
- if (sending_files) { //LCOV_EXCL_START
+ if (sending_files) { /* LCOV_EXCL_START */
file_num = g_list_length(sending_files);
for (i = 0; i < file_num; i++) {
}
g_list_free(sending_files);
- sending_files = NULL; //LCOV_EXCL_STOP
+ sending_files = NULL; /* LCOV_EXCL_STOP */
}
return BT_ERROR_NONE;
char **files = NULL;
BT_CHECK_OPP_CLIENT_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_OPP_CLIENT_INIT_STATUS();
BT_CHECK_INPUT_PARAMETER(remote_address);
if (files)
free(files);
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
int bt_opp_client_cancel_push(void)
int error_code = BT_ERROR_NONE;
BT_CHECK_OPP_CLIENT_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_OPP_CLIENT_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_opc_cancel_push());
error_code);
}
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
#define BT_CHECK_OPP_SERVER_SUPPORT() \
{ \
BT_CHECK_BT_SUPPORT(); \
- LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_SUPPORTED); \
+ LOGE("[%s] NOT_SUPPORTED(0x%08x)", __FUNCTION__, \
+ BT_ERROR_NOT_SUPPORTED); \
return BT_ERROR_NOT_SUPPORTED; \
}
#else
#define BT_CHECK_OPP_SERVER_INIT_STATUS() \
- if (__bt_check_opp_server_init_status() == BT_ERROR_NOT_INITIALIZED) \
- { \
- LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+ if (__bt_check_opp_server_init_status() == BT_ERROR_NOT_INITIALIZED) { \
+ LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, \
+ BT_ERROR_NOT_INITIALIZED); \
return BT_ERROR_NOT_INITIALIZED; \
}
return BT_ERROR_NONE;
}
-//LCOV_EXCL_START
+
+/* LCOV_EXCL_START */
int bt_opp_server_initialize(const char *destination,
bt_opp_server_push_requested_cb push_requested_cb,
void *user_data)
is_opp_server_initialized = true;
return BT_ERROR_NONE;
}
-//LCOV_EXCL_STOP
+
+/* LCOV_EXCL_START */
int bt_opp_server_initialize_by_connection_request(const char *destination,
- bt_opp_server_connection_requested_cb connection_requested_cb,
- void *user_data)
+ bt_opp_server_connection_requested_cb connection_requested_cb,
+ void *user_data)
{
int error_code = BT_ERROR_NONE;
error_code = _bt_get_error_code(bluetooth_obex_server_init_without_agent(destination));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
error_code);
- return error_code; //LCOV_EXCL_LINE //LCOV_EXCL_LINE
+ return error_code; /* LCOV_EXCL_LINE */
}
_bt_set_cb(BT_EVENT_OPP_CONNECTION_REQUESTED, connection_requested_cb, user_data);
BT_CHECK_OPP_SERVER_INIT_STATUS();
if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
- error_code = _bt_get_error_code(bluetooth_obex_server_deinit()); //LCOV_EXCL_LINE
+ error_code = _bt_get_error_code(bluetooth_obex_server_deinit()); /* LCOV_EXCL_LINE */
} else {
/* BADA API */
error_code = _bt_get_error_code(bluetooth_obex_server_deinit_without_agent());
_bt_unset_cb(BT_EVENT_OPP_PUSH_REQUESTED);
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
error_code);
- return error_code; //LCOV_EXCL_LINE
+ return error_code; /* LCOV_EXCL_LINE */
}
is_opp_server_initialized = false;
BT_CHECK_OPP_SERVER_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_OPP_SERVER_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_OPP_SERVER_INIT_STATUS(); /* LCOV_EXCL_START */
/* Unset the transfer callbacks */
_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS);
_bt_set_cb(BT_EVENT_OPP_SERVER_TRANSFER_FINISHED, finished_cb, user_data);
}
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
int bt_opp_server_reject(void)
BT_CHECK_OPP_SERVER_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_OPP_SERVER_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_OPP_SERVER_INIT_STATUS(); /* LCOV_EXCL_START */
if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
error_code = _bt_get_error_code(bluetooth_obex_server_reject_authorize());
_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS);
_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_FINISHED);
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
int bt_opp_server_set_destination(const char *destination)
error_code = _bt_get_error_code(bluetooth_obex_server_set_destination_path(destination));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
error_code);
}
BT_CHECK_OPP_SERVER_SUPPORT();
BT_CHECK_INIT_STATUS();
- BT_CHECK_OPP_SERVER_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_OPP_SERVER_INIT_STATUS(); /* LCOV_EXCL_START */
error_code = _bt_get_error_code(bluetooth_obex_server_cancel_transfer(transfer_id));
if (error_code != BT_ERROR_NONE) {
error_code);
}
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
#else
#define BT_CHECK_PAN_SUPPORT()
#endif
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_nap_activate(void)
{
int error = BT_ERROR_NONE;
}
return error;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
app_param.maxlist = maxlistcount;
app_param.search_attribute = search_attribute;
strncpy(app_param.search_value, search_value,
- BLUETOOTH_PBAP_MAX_SEARCH_VALUE_LENGTH -1 );
+ BLUETOOTH_PBAP_MAX_SEARCH_VALUE_LENGTH - 1);
_bt_set_cb(BT_EVENT_PBAP_PHONEBOOK_SEARCH, callback, user_data);
error_code = _bt_get_error_code(bluetooth_pbap_phonebook_search(&addr_hex, &folder, &app_param));
ret = bluetooth_rfcomm_create_socket(uuid);
if (ret < 0) {
- ret = _bt_get_error_code(ret); //LCOV_EXCL_LINE
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); //LCOV_EXCL_LINE
- return ret; //LCOV_EXCL_LINE
+ ret = _bt_get_error_code(ret); /* LCOV_EXCL_LINE */
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); /* LCOV_EXCL_LINE */
+ return ret; /* LCOV_EXCL_LINE */
} else {
*socket_fd = ret;
return BT_ERROR_NONE;
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_rfcomm_remove_socket(socket_fd));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
error_code);
}
return error_code;
}
-//LCOV_EXCL_START
-int bt_socket_is_service_used(const char* service_uuid, bool *used)
+/* LCOV_EXCL_START */
+int bt_socket_is_service_used(const char *service_uuid, bool *used)
{
BT_CHECK_BT_SUPPORT();
BT_CHECK_INIT_STATUS();
*used = bluetooth_rfcomm_is_server_uuid_available(service_uuid);
- return BT_ERROR_NONE; //LCOV_EXCL_STOP
+ return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
}
int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connections)
BT_CHECK_INIT_STATUS();
error_code = _bt_get_error_code(bluetooth_rfcomm_listen_and_accept(socket_fd, max_pending_connections));
if (error_code != BT_ERROR_NONE) {
- BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), //LCOV_EXCL_LINE
+ BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
error_code);
}
return error_code;
}
-//LCOV_EXCL_START
+/* LCOV_EXCL_START */
int bt_socket_listen(int socket_fd, int max_pending_connections)
{
int error_code = BT_ERROR_NONE;
return error_code;
}
-//LCOV_EXCL_STOP
+/* LCOV_EXCL_STOP */
int bt_socket_connect_rfcomm(const char *remote_address, const char *remote_port_uuid)
{
bluetooth_device_address_t addr_hex = { {0,} };
int error_code = BT_ERROR_NONE;
BT_CHECK_BT_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(remote_address);
BT_CHECK_INPUT_PARAMETER(remote_port_uuid);
error_code);
}
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
int bt_socket_disconnect_rfcomm(int socket_fd)
int error_code = BT_ERROR_NONE;
BT_CHECK_BT_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
error_code = _bt_get_error_code(bluetooth_rfcomm_disconnect(socket_fd));
if (error_code != BT_ERROR_NONE) {
error_code);
}
- return error_code; //LCOV_EXCL_STOP
+ return error_code; /* LCOV_EXCL_STOP */
}
int bt_socket_send_data(int socket_fd, const char *data, int length)
int ret = 0;
BT_CHECK_BT_SUPPORT();
- BT_CHECK_INIT_STATUS(); //LCOV_EXCL_START
+ BT_CHECK_INIT_STATUS(); /* LCOV_EXCL_START */
BT_CHECK_INPUT_PARAMETER(data);
ret = bluetooth_rfcomm_write(socket_fd, data, length);
BT_ERR("Write failed, ret = %d", ret);
}
- return ret; //LCOV_EXCL_STOP
+ return ret; /* LCOV_EXCL_STOP */
}
int bt_socket_set_data_received_cb(bt_socket_data_received_cb callback, void *user_data)
projects / platform / core / api / bluetooth.git / commitdiff