#ADD_DEFINITIONS("-DTIZEN_FEATURE_BT_HPS")
ADD_DEFINITIONS("-DTIZEN_FEATURE_BT_OTP")
-ADD_DEFINITIONS("-DTIZEN_FEATURE_BT_DPM")
ADD_DEFINITIONS("-DTIZEN_GATT_CLIENT")
ADD_LIBRARY(bluetooth-api SHARED ${SRCS})
BT_EXPORT_API int bluetooth_check_adapter(void)
{
int value = VCONFKEY_BT_STATUS_OFF;
-
-#ifndef TIZEN_TEST_EMUL
int ret;
ret = _bt_get_adapter_path(_bt_get_system_private_conn(), NULL);
if (ret != BLUETOOTH_ERROR_NONE)
return BLUETOOTH_ADAPTER_DISABLED;
-#endif
/* check VCONFKEY_BT_STATUS */
if (vconf_get_int(VCONFKEY_BT_STATUS, &value) != 0) {
_bt_print_api_caller_name();
retv_if(bluetooth_check_adapter() == BLUETOOTH_ADAPTER_ENABLED,
BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
-
-#ifdef TIZEN_FEATURE_BT_DPM
retv_if(bluetooth_dpm_is_mode_allowed() == BLUETOOTH_ERROR_PERMISSION_DEINED,
BLUETOOTH_ERROR_PERMISSION_DEINED);
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
retv_if(bluetooth_get_battery_monitor_state() == FALSE,
BLUETOOTH_ERROR_NOT_SUPPORT);
-#ifdef TIZEN_FEATURE_BT_DPM
retv_if(bluetooth_dpm_is_mode_allowed() == BLUETOOTH_ERROR_PERMISSION_DEINED,
BLUETOOTH_ERROR_PERMISSION_DEINED);
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
BT_EXPORT_API int bluetooth_audio_init(bt_audio_func_ptr cb, void *user_data)
{
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
}
-#endif
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
g_array_append_vals(in_param1, remote_address, sizeof(bluetooth_device_address_t));
-#ifdef TIZEN_FEATURE_BT_DPM
if (service_function == BT_AV_CONNECT)
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AV_CONNECT,
in_param1, in_param2, in_param3, in_param4,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
else /* default case - with or without DPM enabled */
-#endif
+
result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_AUDIO_CONNECT,
in_param1, in_param2, in_param3, in_param4,
user_info->cb, user_info->user_data);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
}
-#endif
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
}
-#endif
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
BT_ERR("Not allow to use A2DP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
user_info = _bt_get_user_data(BT_AUDIO);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_HSP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use HSP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
BT_EXPORT_API int bluetooth_media_player_init(media_cb_func_ptr callback_ptr,
void *user_data)
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(setting, return);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(metadata, return);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, remote_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
user_info = _bt_get_user_data(BT_AVRCP);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
+
user_info = _bt_get_user_data(BT_AVRCP);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
+
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
+
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(value, return);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
BT_CHECK_PARAMETER(metadata, return);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_AVRCP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use AVRCP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INIT_PARAMS();
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
#include "bluetooth-gatt-server-api.h"
#endif
-#ifdef TIZEN_GATT_CLIENT
#include "bluetooth-gatt-client-api.h"
-#endif
-
#include "bluetooth-mesh-api.h"
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
static bt_user_info_t user_info[BT_MAX_USER_INFO];
static GDBusConnection *system_shared_conn = NULL;
user_data);
}
-#ifdef TIZEN_GATT_CLIENT
void _bt_gatt_client_event_cb(int event, int result, void *param,
void *callback, void *user_data)
{
BT_ERR("GATT Client event callback is not registered!!!");
}
}
-#endif
#ifndef GATT_DIRECT
void _bt_gatt_server_event_cb(int event, int result, void *param,
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
BT_EXPORT_API int bluetooth_disconnect_device(const bluetooth_device_address_t *remote_address)
{
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_PAIRING, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to pair the device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
user_info = _bt_get_user_data(BT_COMMON);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
return result;
}
-#ifdef TIZEN_GATT_CLIENT
BT_EXPORT_API int bluetooth_connect_le(const bluetooth_device_address_t *device_address,
gboolean auto_connect, int client_id)
-#else
-BT_EXPORT_API int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect)
-#endif
{
int result;
bt_user_info_t *user_info;
g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
g_array_append_vals(in_param2, &auto_connect, sizeof(gboolean));
-
-#ifdef TIZEN_GATT_CLIENT
g_array_append_vals(in_param3, &client_id, sizeof(int));
-#endif
user_info = _bt_get_user_data(BT_COMMON);
retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
return result;
}
-#ifdef TIZEN_GATT_CLIENT
BT_EXPORT_API int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address,
int client_id)
-#else
-BT_EXPORT_API int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address)
-#endif
{
int result;
bt_user_info_t *user_info;
BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
-#ifdef TIZEN_GATT_CLIENT
- BT_DBG("Send GATT disconnect using Client Interface [%d]", client_id);
g_array_append_vals(in_param2, &client_id, sizeof(int));
-#endif
+
+ BT_DBG("Send GATT disconnect using Client Interface [%d]", client_id);
+
user_info = _bt_get_user_data(BT_COMMON);
retv_if(user_info == NULL, BLUETOOTH_ERROR_INTERNAL);
*
*/
-#ifdef TIZEN_FEATURE_BT_DPM
#include <vconf.h>
#include "bluetooth-api.h"
#include "bt-event-handler.h"
#include "bt-dpm.h"
-#ifdef TIZEN_FEATURE_BT_DPM
BT_EXPORT_API int bluetooth_dpm_is_mode_allowed(void)
{
int value;
else
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#endif
-
-#if 0
-static bt_dpm_status_e _bt_check_dpm_allow_restriction(void)
-{
- bt_dpm_allow_t mode;
-
- bluetooth_dpm_get_allow_mode(&mode);
-
- return (mode == BLUETOOTH_DPM_BT_RESTRICTED) ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED;
-}
-#endif
static bt_dpm_status_e _bt_check_dpm_handsfree_only(void)
{
return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
}
-#if 0
-static bt_dpm_status_e _bt_check_dpm_visible_restriction(void)
-{
- bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
-
- bluetooth_dpm_get_desktop_connectivity_state(&dpm_status);
-
- return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
-}
-
-static bt_dpm_status_e _bt_check_dpm_limited_discoverable_mode(void)
-{
- bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
-
- bluetooth_dpm_get_limited_discoverable_state(&dpm_status);
-
- return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
-}
-#endif
-
static bt_dpm_status_e _bt_check_dpm_blacklist_device(bluetooth_device_address_t *address)
{
int ret = BLUETOOTH_DPM_RESULT_SUCCESS;
BT_EXPORT_API int bluetooth_dpm_set_allow_mode(bt_dpm_allow_t value)
{
int result = BLUETOOTH_ERROR_NONE;
-#ifdef TIZEN_FEATURE_BT_DPM
int bt_status;
-#endif
-#ifdef TIZEN_FEATURE_BT_DPM
if (value >= BLUETOOTH_DPM_BT_ALLOWED &&
value <= BLUETOOTH_DPM_BT_RESTRICTED) {
if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
result = bluetooth_disable_adapter();
}
}
-#else
- BT_INIT_PARAMS();
- BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
- g_array_append_vals(in_param1, &value, sizeof(int));
-
- result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_BT_MODE,
- in_param1, in_param2, in_param3, in_param4, &out_param);
-
- BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-#endif
return result;
{
int result;
-#ifdef TIZEN_FEATURE_BT_DPM
if (vconf_get_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
BT_ERR("fail to get vconf key!");
return BLUETOOTH_ERROR_INTERNAL;
}
result = BLUETOOTH_ERROR_NONE;
-#else
- BT_CHECK_ENABLED_ANY(return);
-
- BT_INIT_PARAMS();
- BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
- result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_BT_MODE,
- in_param1, in_param2, in_param3, in_param4, &out_param);
-
- if (result == BLUETOOTH_ERROR_NONE) {
- if (out_param->len > 0) {
- *value = g_array_index(out_param,
- int, 0);
- } else {
- BT_ERR("out_param length is 0!!");
- }
- }
-
- BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-#endif
return result;
}
return result;
}
-#endif /* #ifdef TIZEN_FEATURE_BT_DPM */
#endif
ret_if(signal_name == NULL);
-#ifdef TIZEN_GATT_CLIENT
+
if (strcasecmp(signal_name, BT_GATT_SERVER_CONNECTED) == 0) {
const char *address = NULL;
bluetooth_device_address_t dev_address = { {0} };
_bt_common_event_cb(BLUETOOTH_EVENT_GATT_CLIENT_DISCONNECTED,
result, &dev_address,
event_info->cb, event_info->user_data);
-#else
- if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
- const char *address = NULL;
- bluetooth_device_address_t dev_address = { {0} };
- BT_DBG("BT_GATT_CONNECTED");
- g_variant_get(parameters, "(i&s)", &result, &address);
-
- _bt_convert_addr_string_to_type(dev_address.addr, address);
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
- result, &dev_address,
- event_info->cb, event_info->user_data);
- } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
- const char *address = NULL;
- bluetooth_device_address_t dev_address = { {0} };
- BT_DBG("BT_GATT_DISCONNECTED");
- g_variant_get(parameters, "(i&s)", &result, &address);
-
- _bt_convert_addr_string_to_type(dev_address.addr, address);
- _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
- result, &dev_address,
- event_info->cb, event_info->user_data);
-#endif
} else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
const char *address = NULL;
bluetooth_device_address_t dev_address = { {0} };
_bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
result, &gain,
event_info->cb, event_info->user_data);
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
} else if (strcasecmp(signal_name, BT_AUDIO_AVC_MODE_CHANGED) == 0) {
bool mode;
result, &volume,
event_info->cb, event_info->user_data);
}
-#endif
}
void __bt_hid_device_event_filter(GDBusConnection *connection,
g_free(cb_data);
}
-#ifdef TIZEN_GATT_CLIENT
static void __bt_gatt_client_event_filter(GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
}
}
-#endif
-
-
#ifndef GATT_DIRECT
static void __bt_gatt_server_event_filter(GDBusConnection *connection,
const gchar *sender_name,
event_info = (bt_event_info_t *)user_data;
ret_if(event_info == NULL);
-#ifdef TIZEN_GATT_CLIENT
- if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
-#else
- if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
- const char *address = NULL;
- bluetooth_device_address_t dev_address = { {0} };
- BT_DBG("BT_GATT_CONNECTED");
- g_variant_get(parameters, "(i&s)", &result, &address);
-
- _bt_convert_addr_string_to_type(dev_address.addr, address);
- _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
- result, &dev_address,
- event_info->cb, event_info->user_data);
- } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
- const char *address = NULL;
- bluetooth_device_address_t dev_address = { {0} };
- BT_DBG("BT_GATT_DISCONNECTED");
- g_variant_get(parameters, "(i&s)", &result, &address);
- _bt_convert_addr_string_to_type(dev_address.addr, address);
- _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
- result, &dev_address,
- event_info->cb, event_info->user_data);
- } else if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
-#endif
+ if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
const char *address = NULL;
GVariant *data_var = NULL;
bluetooth_device_address_t dev_address = { {0} };
path = BT_GATT_SERVER_PATH;
break;
#endif
-
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_CLIENT_EVENT:
event_func = __bt_gatt_client_event_filter;
path = BT_GATT_CLIENT_PATH;
break;
-#endif
case BT_MESH_EVENT:
event_func = __bt_mesh_event_filter;
path = BT_MESH_PATH;
#include "bt-internal-types.h"
#include "bt-request-sender.h"
-#ifdef TIZEN_GATT_CLIENT
#include "bluetooth-gatt-client-api.h"
#include <arpa/inet.h>
static GSList *gatt_characteristic_notify_list;
static GSList *gatt_characteristic_write_list = NULL;;
-#endif
#define GATT_DEFAULT_TIMEOUT (6 * 1000) // Dependent on supervision timeout 6 sec
{
BT_CHECK_PARAMETER(svc_pty, return);
-#ifdef TIZEN_GATT_CLIENT
- g_free(svc_pty->uuid);
-#else
g_free(svc_pty->uuid);
- g_free(svc_pty->handle);
- g_strfreev(svc_pty->include_handles.handle);
- g_strfreev(svc_pty->char_handle.handle);
-#endif
memset(svc_pty, 0, sizeof(bt_gatt_service_property_t));
g_free(char_pty->name);
g_free(char_pty->description);
g_free(char_pty->val);
-#ifndef TIZEN_GATT_CLIENT
- g_free(char_pty->handle);
- g_strfreev(char_pty->char_desc_handle.handle);
-#endif
memset(char_pty, 0, sizeof(bt_gatt_char_property_t));
g_free(desc_pty->uuid);
g_free(desc_pty->val);
-#ifndef TIZEN_GATT_CLIENT
- g_free(desc_pty->handle);
-#endif
memset(desc_pty, 0, sizeof(bt_gatt_char_descriptor_property_t));
return ret;
}
-#ifdef TIZEN_GATT_CLIENT
void __bt_uuid_hex_to_string(unsigned char *uuid, char *str)
{
uint32_t uuid0, uuid4;
BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
return result;
}
-
-#endif
return err;
}
-
-#if 0
-BT_EXPORT_API int bluetooth_gatt_register_application(int instance_id)
-{
- BT_INIT_PARAMS();
-
- if (!is_server_started) {
-
- if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_GATT_REGISTER_APPLICATION)
- == BLUETOOTH_ERROR_PERMISSION_DEINED) {
- BT_ERR("Don't have aprivilege to use this API");
- return BLUETOOTH_ERROR_PERMISSION_DEINED;
- }
-
- BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
- g_array_append_vals(in_param1, &instance_id, sizeof(int));
-
- ret = _bt_send_request(BT_BLUEZ_SERVICE, BT_GATT_REGISTER_APPLICATION,
- in_param1, in_param2, in_param3, in_param4, &out_param);
- BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
-
- if (ret != BLUETOOTH_ERROR_NONE) {
- BT_ERR("Register application failed");
- return ret;
- }
- is_server_started = true;
-
- return BLUETOOTH_ERROR_NONE;
- }
-
- BT_INFO("Already RegisterApplication");
- return BLUETOOTH_ERROR_NONE;
-}
-#endif
-
BT_EXPORT_API int bluetooth_gatt_server_init(int *instance_id, gatt_server_cb_func_ptr callback_ptr,
void *user_data)
{
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
BT_EXPORT_API int bluetooth_hid_init(hid_cb_func_ptr callback_ptr, void *user_data)
{
BT_ERR("Don't have a privilege to use this API");
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
+
if (_bt_check_dpm(BT_DPM_ADDRESS, device_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
BT_ERR("Blacklist uuid");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
user_info = _bt_get_user_data(BT_HID);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
BT_EXPORT_API int bluetooth_network_activate_server()
{
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
char *uuid = NULL;
if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)device_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
}
}
g_free(uuid);
-#endif
user_info = _bt_get_user_data(BT_COMMON);
retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
static void __bt_get_file_size(char **files, unsigned long *file_size, int *count)
{
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, remote_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
}
-#endif
__bt_get_file_size(file_name_array, &size, &file_count);
retv_if(file_count == 0, BLUETOOTH_ERROR_INVALID_PARAM);
#include "bt-request-sender.h"
#include "bt-event-handler.h"
#include "bluetooth-media-control.h"
-
-#ifdef TIZEN_GATT_CLIENT
#include "bluetooth-gatt-client-api.h"
-#endif
-
#include "bluetooth-mesh-api.h"
static GSList *sending_requests;
*param_data = &g_array_index(output,
bluetooth_device_address_t, 0);
break;
-#ifdef TIZEN_GATT_CLIENT
case BT_CONNECT_LE:
*event_type = BT_DEVICE_EVENT;
*event = BLUETOOTH_EVENT_GATT_CLIENT_CONNECTED;
*param_data = &g_array_index(output,
bluetooth_device_address_t, 0);
break;
-#else
- case BT_CONNECT_LE:
- *event_type = BT_DEVICE_EVENT;
- *event = BLUETOOTH_EVENT_GATT_CONNECTED;
- ret_if(output == NULL);
- *param_data = &g_array_index(output,
- bluetooth_device_address_t, 0);
- break;
- case BT_DISCONNECT_LE:
- *event_type = BT_DEVICE_EVENT;
- *event = BLUETOOTH_EVENT_GATT_DISCONNECTED;
- ret_if(output == NULL);
- *param_data = &g_array_index(output,
- bluetooth_device_address_t, 0);
- break;
-#endif
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_READ_CHARACTERISTIC:
BT_INFO("BT_GATT_READ_CHARACTERISTIC");
*event_type = BT_GATT_CLIENT_EVENT;
*param_data = &g_array_index(output,
bluetooth_gatt_client_desc_prop_info_t, 0);
break;
-#endif
case BT_TDS_READ_TRANSPORT_DATA:
*event_type = BT_TDS_EVENT;
*event = BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED;
} else if (event_type == BT_AVRCP_EVENT) {
((bluetooth_cb_func_ptr)cb_data->cb)(bt_event.event,
&bt_event, cb_data->user_data);
-#ifdef TIZEN_GATT_CLIENT
} else if (event_type == BT_GATT_CLIENT_EVENT) {
((gatt_client_cb_func_ptr)cb_data->cb)(bt_event.event,
(gatt_client_event_param_t*)&bt_event, cb_data->user_data);
-#endif
} else if (event_type == BT_MESH_EVENT) {
((mesh_cb_func_ptr)cb_data->cb)(bt_event.event,
(mesh_event_param_t*)&bt_event, cb_data->user_data);
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
/* Variable for privilege, only for write API,
before we should reduce time to bt-service dbus calling
BT_CHECK_PARAMETER(remote_uuid, return);
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_ADDRESS, (void *)remote_bt_address) == BT_DPM_RESTRICTED) {
BT_ERR("Blacklist device");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
}
-#endif
#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
BT_INFO_C("### Connect RFCOMM");
#include "bt-common.h"
#include "bt-request-sender.h"
#include "bt-event-handler.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-dpm.h"
-#endif
#define BLUETOOTH_SOCK_CONNECT_INFO_LEN 16
#define BATTERY_MONITOR_RFCOMM_INTERVAL 5
return -1;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
char addr_str[20];
return -1;
}
-#endif
conn = g_new0(rfcomm_conn_t, 1);
conn->fd = fd;
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use SPP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
BT_INFO("<<<<<<<<< RFCOMM Create socket from app >>>>>>>>>");
return BLUETOOTH_ERROR_PERMISSION_DEINED;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use SPP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INFO("<<<<<<<<< RFCOMM Create socket from app >>>>>>>>>");
info = __register_method_2(path, bus_name);
return BLUETOOTH_ERROR_INVALID_PARAM;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use SPP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
BT_INFO("RFCOMM Listen & accept from app");
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use SPP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
BT_INFO("RFCOMM Listen & accept from app");
return BLUETOOTH_ERROR_INVALID_PARAM;
}
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use SPP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
BT_INFO("RFCOMM Listen");
BT_CHECK_ENABLED(return);
-#ifdef TIZEN_FEATURE_BT_DPM
if (_bt_check_dpm(BT_DPM_SPP, NULL) == BT_DPM_RESTRICTED) {
BT_ERR("Not allow to use SPP profile");
return BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION;
}
-#endif
if (server_fd < 0) {
BT_ERR("Invalid FD");
BT_EXPORT_API int bluetooth_telephony_set_active_headset(const char *remote_addr)
{
-#ifdef TIZEN_BT_DUAL_HEADSET_CONNECT
GVariant *reply;
GVariant *param;
GError *err = NULL;
g_variant_unref(reply);
return BLUETOOTH_TELEPHONY_ERROR_NONE;
-#else
- return BLUETOOTH_ERROR_NOT_SUPPORT;
-#endif
}
static void __bt_telephony_adapter_filter(GDBusConnection *connection,
#ifndef GATT_DIRECT
BT_GATT_SERVER,
#endif
-
-#ifdef TIZEN_GATT_CLIENT
BT_GATT_CLIENT,
-#endif
BT_MESH,
BT_MAX_USER_INFO
} bt_user_info_type_t;
void *callback, void *user_data);
#endif
-#ifdef TIZEN_GATT_CLIENT
void _bt_gatt_client_event_cb(int event, int result, void *param,
void *callback, void *user_data);
-#endif
/*Mesh*/
void _bt_mesh_event_cb(int event, int result, void *param,
*
*/
-#ifdef TIZEN_FEATURE_BT_DPM
-
#ifndef _BT_DPM_H_
#define _BT_DPM_H_
}
#endif /* __cplusplus */
#endif /*_BT_SERVICE_DPM_H_*/
-#endif /* #ifdef TIZEN_FEATURE_BT_DPM */
#include <bundle.h>
#include <eventsystem.h>
#include <stdio.h>
-#ifdef TIZEN_FEATURE_ACTD
#include <actd/unit_control.h>
-#endif
#include "bt-core-main.h"
#include "bt-core-adapter.h"
}
}
-#ifdef TIZEN_FEATURE_ACTD
static int __bt_call_systemact_service(const char *service_name)
{
int ret;
return 0;
}
-#else
-static int __bt_call_systemact_service(const char *file_path)
-{
- BT_DBG("+");
- FILE *fp;
-
- if (!file_path) {
- BT_ERR("service file path is NULL");
- return -1;
- }
-
- if (!access(file_path, F_OK)) {
- remove(file_path);
- usleep(100);
- }
-
- fp = fopen(file_path, "w");
- if (!fp) {
- BT_ERR("Failed to fopen service file");
- return -1;
- }
-
-
- fclose(fp);
- BT_DBG("-");
- return 0;
-
-}
-#endif
static int __execute_command(const char *cmd, char *const arg_list[])
{
{
int ret;
bt_status_t status;
-#if 0
- bt_le_status_t le_status;
-#endif
+
BT_INFO("");
status = _bt_core_get_status();
return -1;
}
-#if 0 /* only the concept of private */
+/* only the concept of private
+#if 0
+ bt_le_status_t le_status;
+
le_status = _bt_core_get_le_status();
if (le_status == BT_LE_ACTIVATED) {
- /* Turn on PSCAN, (ISCAN if needed) */
- /* Return with 0 for the Enabled response. */
+ // Turn on PSCAN, (ISCAN if needed)
+ // Return with 0 for the Enabled response.
__bt_core_set_status(BT_ACTIVATED);
BT_INFO("BR/EDR is enabled.");
g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
return 0;
}
#endif
+*/
__bt_core_set_status(BT_ACTIVATING);
if (TIZEN_FEATURE_BT_USB_DONGLE) {
int _bt_disable_adapter(void)
{
bt_status_t status;
-#if 0
- bt_le_status_t le_status;
-#endif
BT_INFO_C("Disable adapter");
-#if 0 /* only the concept of private */
+/* only the concept of private
+#if 0
+ bt_le_status_t le_status;
+
le_status = _bt_core_get_le_status();
BT_DBG("le_status : %d", le_status);
if (le_status == BT_LE_ACTIVATED) {
- /* Turn off PSCAN, (ISCAN if needed) */
- /* Return with 0 for the Disabled response. */
+ // Turn off PSCAN, (ISCAN if needed)
+ // Return with 0 for the Disabled response.
__bt_core_set_status(BT_DEACTIVATED);
BT_INFO("BR/EDR is disabled. now LE only mode");
g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
return 0;
}
#endif
+*/
status = _bt_core_get_status();
if (status == BT_ACTIVATING) {
if (__bt_call_systemact_service(BT_SYSTEMACT_HCI_DOWN) < 0)
BT_ERR("Failed to call systemact service");
} else {
-#ifdef TIZEN_FEATURE_RADIO
int radio_status = VCONFKEY_RADIO_STATUS_OFF;
/* Check if radio status on or off */
if (__bt_call_systemact_service(BT_SYSTEMACT_STACK_DOWN) < 0)
BT_ERR("running script failed");
}
-#else
- if (__bt_call_systemact_service(BT_SYSTEMACT_STACK_DOWN) < 0)
- BT_ERR("running script failed");
-#endif
}
_bt_core_terminate();
return 0;
}
g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
} else {
-#ifdef TIZEN_FEATURE_RADIO
int radio_status = VCONFKEY_RADIO_STATUS_OFF;
/* Check if radio status on or off */
return -1;
}
}
-#else
- if (__bt_call_systemact_service(BT_SYSTEMACT_STACK_DOWN) < 0) {
- BT_ERR("running script failed");
- __bt_core_set_status(BT_ACTIVATED);
- return -1;
- }
-#endif
}
return 0;
gboolean _bt_core_recover_adapter(void)
{
int ret;
-#if 0
- int ret_le;
-#endif
+
BT_INFO_C("Recover bt adapter");
_bt_set_flightmode_request(FALSE);
if (_bt_core_get_status() == BT_ACTIVATED) {
_bt_core_set_bt_status(BT_RECOVERY_MODE, 1);
-#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
-#endif
}
if (_bt_core_get_le_status() == BT_LE_ACTIVATED) {
_bt_core_set_bt_le_status(BT_RECOVERY_MODE, 1);
-#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
-#endif
}
ret = _bt_disable_adapter();
if (ret < 0)
BT_ERR("_bt_disable_adapter() failed");
-/* In platform, don't seperate BR/EDR and LE status */
+/* In platform, don't seperate BR/EDR and LE status
#if 0
+ int ret_le;
+
ret_le = _bt_disable_adapter_le();
if (ret_le < 0)
BT_ERR("_bt_disable_adapter_le() failed");
#endif
+*/
return TRUE;
}
int ret;
BT_DBG("Test item : %s", type);
-#ifdef TIZEN_FEATURE_ACTD
if (g_strcmp0(type, "Enable_RF_Test") == 0) {
ret = __bt_call_systemact_service(BT_SYSTEMACT_EDUTM_ON);
if (ret < 0)
g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
return FALSE;
}
-#else
- char *cmd = NULL;
- char *arg_list[3] = { NULL, NULL, NULL };
-
- if (g_strcmp0(type, "Enable_RF_Test") == 0) {
- cmd = "/usr/etc/bluetooth/bt-edutm-on.sh";
- arg_list[0] = "bt-edutm-on.sh";
- } else if (g_strcmp0(type, "Disable_RF_Test") == 0) {
- cmd = "/usr/etc/bluetooth/bt-edutm-off.sh";
- arg_list[0] = "bt-edutm-off.sh";
- } else if (g_strcmp0(type, "Slave_Mode") == 0) {
- cmd = "/usr/etc/bluetooth/bt-mode-slave.sh";
- arg_list[0] = "bt-mode-slave.sh";
- } else if (g_strcmp0(type, "Master_Mode") == 0) {
- cmd = "/usr/etc/bluetooth/bt-mode-master.sh";
- arg_list[0] = "bt-mode-master.sh";
- } else if (g_strcmp0(type, "SSP_Debug_Mode") == 0) {
- cmd = "/usr/etc/bluetooth/bt-set-ssp-debug-mode.sh";
- arg_list[0] = "bt-set-ssp-debug-mode.sh";
- arg_list[1] = (char *)arg;
- } else if (g_strcmp0(type, "RF_Channel") == 0) {
- cmd = "/usr/etc/bluetooth/bt-enable-rf-channel.sh";
- arg_list[0] = "bt-enable-rf-channel.sh";
- arg_list[1] = (char *)arg;
- } else {
- return FALSE;
- }
-
- BT_DBG("Run %s", cmd);
- if (__execute_command(cmd, arg_list) < 0)
- BT_ERR("running script failed");
-#endif
return TRUE;
}
BT_ERR("_bt_enable_adapter() failed");
}
-#if 0
- if (_bt_core_get_bt_le_status(BT_RECOVERY_MODE) == 1) {
- _bt_core_set_bt_le_status(BT_RECOVERY_MODE, 0);
- ret = _bt_enable_adapter_le();
- if (ret < 0)
- BT_ERR("_bt_enable_adapter_le() failed");
- }
-#endif
is_recovery_mode = FALSE;
BT_DBG("-");
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
_bt_core_set_bt_status(BT_FLIGHT_MODE, bt_status_before_mode);
-#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
-#endif
_bt_disable_adapter();
}
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
_bt_core_set_bt_le_status(BT_FLIGHT_MODE, bt_le_status_before_mode);
-#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
-#endif
_bt_disable_adapter_le();
}
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
BT_DBG("no bluetooth device info, so BT was disabled at previous session");
+/*
#ifdef ENABLE_TIZEN_2_4
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0)
BT_ERR("no bluetooth le info, so BT LE was disabled at previous session");
#endif
-
+*/
if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &flight_mode_deactivation) != 0)
BT_ERR("Fail to get the flight_mode_deactivation value");
if ((bt_status != VCONFKEY_BT_STATUS_OFF || bt_off_due_to_timeout) &&
(status == BT_DEACTIVATED)) {
BT_DBG("Previous session was enabled.");
-#if 0
- /* Enable the BT */
- _bt_core_service_request_adapter(BT_ENABLE_ADAPTER);
- if (!TIZEN_FEATURE_BT_USB_DONGLE)
- _bt_enable_adapter();
-#endif
} else if (bt_status == VCONFKEY_BT_STATUS_OFF &&
(flight_mode_deactivation == 1 || ps_mode_deactivation > 0)) {
//_bt_core_handle_flight_mode_noti();
- _bt_core_handle_power_saving_mode_noti();
_bt_core_set_bt_status(BT_FLIGHT_MODE, flight_mode_deactivation);
_bt_core_set_bt_status(BT_POWER_SAVING_MODE, ps_mode_deactivation);
if ((bt_le_status == VCONFKEY_BT_LE_STATUS_ON) && (le_status == BT_LE_DEACTIVATED)) {
BT_DBG("Previous session was le enabled. Turn BT LE on automatically.");
-#if 0
- /* Enable the BT LE */
- _bt_core_service_request_adapter(BT_ENABLE_ADAPTER_LE);
- if (!TIZEN_FEATURE_BT_USB_DONGLE)
- _bt_enable_adapter_le();
-#endif
} else {
status = _bt_core_get_status();
le_status = _bt_core_get_le_status();
if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
_bt_core_set_bt_status(BT_POWER_SAVING_MODE, bt_status_before_mode);
-#ifdef TIZEN_FEATURE_BUSACT
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
-#endif
+
if (!TIZEN_FEATURE_BT_USB_DONGLE)
_bt_disable_adapter();
}
if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
_bt_core_set_bt_le_status(BT_POWER_SAVING_MODE, bt_le_status_before_mode);
-#ifdef TIZEN_FEATURE_BUSACT
/* Disable the BT LE */
_bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
-#endif
+
if (!TIZEN_FEATURE_BT_USB_DONGLE)
_bt_disable_adapter_le();
}
}
}
-#ifdef ENABLE_TIZEN_2_4
-static void __bt_core_power_saving_mode_cb(keynode_t *node, void *data)
-{
- int power_saving_mode = 0;
-
- DBG_SECURE("key=%s", vconf_keynode_get_name(node));
-
- if (vconf_keynode_get_type(node) != VCONF_TYPE_INT) {
- BT_ERR("Wrong vconf type");
- return;
- }
-
- power_saving_mode = vconf_keynode_get_int(node);
-
- BT_DBG("value=%d", power_saving_mode);
-
- __bt_core_handle_adapter_with_power_saving_mode(power_saving_mode);
-}
-#endif
-
void _bt_core_init_vconf_value(void)
{
gboolean flight_mode = FALSE;
-#ifndef ENABLE_TIZEN_2_4
int power_saving_mode = 0;
-#endif
int bt_flight_mode = 0;
int bt_ps_mode = 0;
//_bt_core_handle_flight_mode_noti();
- _bt_core_handle_power_saving_mode_noti();
-
flight_mode = _bt_core_is_flight_mode_enabled();
-#ifndef ENABLE_TIZEN_2_4
if (!TIZEN_PROFILE_WEARABLE) {
if (vconf_get_int(VCONFKEY_SETAPPL_PSMODE, &power_saving_mode) != 0)
BT_ERR("Fail to get the power_saving_mode status value");
BT_DBG("flight_mode = %d, power_saving_mode = %d", flight_mode, power_saving_mode);
}
-#endif
+
BT_DBG("flight_mode = %d, power_saving_mode = %d", flight_mode, power_saving_mode);
if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &bt_flight_mode))
if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, &bt_ps_mode))
BT_ERR("Fail get power saving mode value");
_bt_core_set_bt_status(BT_POWER_SAVING_MODE, bt_ps_mode);
-#ifndef ENABLE_TIZEN_2_4
+
if (power_saving_mode > 0)
__bt_core_handle_adapter_with_power_saving_mode(power_saving_mode);
else
BT_ERR("");
-#endif
-}
-
-void _bt_core_handle_power_saving_mode_noti(void)
-{
- if (TIZEN_PROFILE_WEARABLE)
- return;
-
- BT_DBG("+");
-#ifdef ENABLE_TIZEN_2_4
- int ret = 0;
-
- ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
- (vconf_callback_fn)__bt_core_power_saving_mode_cb, NULL);
- if (ret < 0)
- BT_ERR("Unable to register key handler");
-#endif
}
void _bt_core_unregister_vconf_handler(void)
{
-#ifdef ENABLE_TIZEN_2_4
- if (!TIZEN_PROFILE_WEARABLE) {
- vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE,
- (vconf_callback_fn)__bt_core_power_saving_mode_cb);
- }
-#endif
+
}
#define BT_CORE_NAME "org.projectx.bt_core"
#define BT_CORE_PATH "/org/projectx/bt_core"
-#ifdef TIZEN_FEATURE_ACTD
#define BT_SYSTEMACT_HCI_LOGGER_START "bluetooth-hci-logger.service"
#define BT_SYSTEMACT_HCI_LOGGER_STOP "bluetooth-hci-logger-stop.service"
#define BT_SYSTEMACT_HCI_UP "bluetooth-hci-up.service"
#define BT_SYSTEMACT_STACK_DOWN_WITH_RADIO "bluetooth-stack-down-with-radio.service"
#define BT_SYSTEMACT_EDUTM_ON "bluetooth-edutm-on.service"
#define BT_SYSTEMACT_EDUTM_OFF "bluetooth-edutm-off.service"
-#else
-#define BT_SYSTEMACT_HCI_LOGGER_START "/run/.hci_logger_start"
-#define BT_SYSTEMACT_HCI_LOGGER_STOP "/run/.hci_logger_stop"
-#define BT_SYSTEMACT_HCI_UP "/run/.hci_up"
-#define BT_SYSTEMACT_HCI_DOWN "/run/.hci_down"
-#define BT_SYSTEMACT_BLUEZ_START "/run/.bluez_start"
-#define BT_SYSTEMACT_BLUETOOTH_SHARE_START "/run/.bluetooth_share_start"
-#define BT_SYSTEMACT_RFKILL_UNBLOCK "/run/.rfkill_unblock"
-#define BT_SYSTEMACT_RFKILL_BLOCK "/run/.rfkill_block"
-#define BT_SYSTEMACT_STACK_UP "/run/.bt_stack_up"
-#define BT_SYSTEMACT_STACK_DOWN "/run/.bt_stack_down"
-#define BT_SYSTEMACT_STACK_DOWN_WITH_RADIO "/run/.bt_stack_down_with_radio"
-#endif
#define BT_CORE_TYPE (bt_core_get_type())
void _bt_core_init_vconf_value(void);
-void _bt_core_handle_power_saving_mode_noti(void);
void _bt_core_unregister_vconf_handler(void);
#ifdef __cplusplus
uint8_t net_uuid[16];
} __attribute__((packed));
-#if 0
+/*
#define HAL_EV_MESH_SCAN_FINISHED 0xD4
struct hal_ev_mesh_scan_finished {
uint8_t status;
uint8_t net_uuid[16];
} __attribute__((packed));
-#endif
+*/
#define HAL_EV_MESH_SCAN_RESULT 0xD5
struct hal_ev_mesh_scan_result {
static inline void stack_trim(void)
{
+/*
#ifdef STACK_FLUSH
unsigned int sp;
char buf[BUF_SIZE];
perror("stack madvise fail");
}
#endif
+*/
}
}
}
-#if 0
-static const char *__shuffle_val_to_str(btrc_player_shuffle_val_t shuffle_val)
-{
- switch (shuffle_val) {
- case BTRC_PLAYER_VAL_OFF_SHUFFLE:
- return "off";
- case BTRC_PLAYER_VAL_ALL_SHUFFLE:
- return "alltracks";
- case BTRC_PLAYER_VAL_GROUP_SHUFFLE:
- return "group";
- default:
- ERR("Invalid shuffle value: %d", shuffle_val);
- return "";
- }
-}
-#endif
-
static const char *__play_status_to_str(btrc_play_status_t play_status)
{
switch (play_status) {
memset(&ev, 0, sizeof(ev));
char dev_address[18];
-#if TODO_40
+/* #if TODO_40 */
/* Terminate ALL system popup */
+/*
if (headed_plugin_info->plugin_headed_enabled)
headed_plugin_info->headed_plugin->bt_destroy_popup_all();
#endif
+*/
g_dbus_proxy_call_finish(proxy, res, &err);
device_path = g_dbus_proxy_get_object_path(proxy);
return BT_STATUS_FAIL;
}
-#if 0
+/*
// TODO: This logic is not able to handle in case service-added event is coming unexpectedly.
- /* Check the service info is stored */
+ // Check the service info is stored
if (g_slist_length(conn_info->gatt_list_services) > 0) {
GSList *l = NULL;
hal_gattc_service_t *svc_info = NULL;
} else {
DBG("No stored service, request to bluez");
}
-#endif
-
+*/
_bt_hal_convert_addr_type_to_string(device_address,
(unsigned char *)conn_info->bd_addr.address);
char *desc_flags[NUMBER_OF_FLAGS];
int flag_count = 0;
int *app_id;
-
hal_gatt_desc_added *user_data = NULL;
-#if 0
- if (new_char) {
- desc_id = 1;
- new_char = FALSE;
- }
-#endif
+
/* Fetch service data for the GATT server */
serv_info = __bt_gatt_find_gatt_service_info(slot, service_handle);
if (serv_info == NULL)
API_TRACE();
/*TODO: Need to check below logic */
-#if 0
+ /*
if (a2dp_sink_enable_state() == TRUE || avrcp_ct_enable_state() == TRUE) {
BT_ERR("AVRCP_CT Role Enabled, cannot enable AVRCP_TG Role");
return OAL_STATUS_BUSY;
}
-#endif
+ */
blued_api = adapter_get_stack_interface();
if (blued_api == NULL) {
return OAL_STATUS_SUCCESS;
}
-#if 0
-/* Below API's need to be removed as they are hardcoded API's.
- If at all, product specific API's are required to set specific data, then new naming should
- be adopted for these API's */
-oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
-{
- int ret = OAL_STATUS_SUCCESS;
-
- API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
- CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
-
- /* Historically used for Legacy Advertising */
- return OAL_STATUS_NOT_SUPPORT;
-}
-
-oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
-{
- int ret = OAL_STATUS_SUCCESS;
-
- API_TRACE("Set advertising data");
- CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
-
- /* Historically used for Legacy Advertising */
- return OAL_STATUS_NOT_SUPPORT;
-}
-
-oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
-{
- int ret = OAL_STATUS_SUCCESS;
-
- API_TRACE("Set Scan Response data");
- CHECK_OAL_GATT_ENABLED();
- CHECK_SERVER_INSTANCE(instance_id);
- CHECK_SERVER_REGISTRATION(instance_id);
-
- /* Historically used for Legacy Advertising */
- return OAL_STATUS_NOT_SUPPORT;
-}
-#endif
-
oal_status_t gatts_multi_adv_enable(int instance_id)
{
int ret = OAL_STATUS_SUCCESS;
./services/health/bt-service-hdp.c
./services/audio/avrcp/bt-service-avrcp-tg.c
./services/audio/avrcp/bt-service-avrcp-ctrl.c
+./services/audio/bt-service-absolute-volume.c
./services/gatt/bt-service-gatt.c
./services/audio/hf/bt-service-hf-client.c
./services/mesh/bt-service-mesh-util.c
LIST(APPEND SRCS ./services/ipsp/bt-service-ipsp-event-receiver.c)
ENDIF()
-IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_FEATURE_BT_AVC_TARGET")
-LIST(APPEND SRCS ./services/audio/bt-service-absolute-volume.c)
-ENDIF()
-
IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
SET(CMAKE_BUILD_TYPE "Release")
ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
ADD_DEFINITIONS("-DAPP_LOCALEDIR=\"${APP_LOCALEDIR}\"")
ADD_DEFINITIONS("-DAPP_SYSCONFDIR=\"${APP_SYSCONFDIR}\"")
ADD_DEFINITIONS("-DHPS_FEATURE")
-ADD_DEFINITIONS("-DTIZEN_FEATURE_BT_DPM")
SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie")
#include "bt-service-audio-common.h"
#include "bt-service-core-adapter-le.h"
#include "bt-service-gatt.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
-#endif
#include "bt-service-hidhost.h"
#include "bt-service-hiddevice.h"
#include "bt-service-socket.h"
int _bt_start_visibility_timer(int timeout)
{
int result;
-#ifdef TIZEN_FEATURE_BT_DPM
int discoverable_state = DPM_BT_ERROR;
-#endif
__bt_visibility_alarm_remove();
visible_timer.timeout = timeout;
-#ifdef TIZEN_FEATURE_BT_DPM
_bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
if (discoverable_state != DPM_RESTRICTED) {
-#endif
if (vconf_set_int(BT_FILE_VISIBLE_TIME, timeout) != 0)
BT_ERR("Set vconf failed");
-#ifdef TIZEN_FEATURE_BT_DPM
}
-#endif
if (timeout <= 0)
return BLUETOOTH_ERROR_NONE;
{
int result;
int ret = BLUETOOTH_ERROR_NONE;;
-#ifdef TIZEN_FEATURE_BT_DPM
int discoverable_state = DPM_BT_ERROR;
-#endif
BT_DBG("+");
BT_INFO("discoverable_mode: %d, timeout: %d", discoverable_mode, timeout);
-#ifdef TIZEN_FEATURE_BT_DPM
_bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
if (discoverable_mode != BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE &&
discoverable_state == DPM_RESTRICTED) {
headed_plugin_info->headed_plugin->bt_launch_dpmpopup("DPM_POLICY_DISABLE_BT");
return BLUETOOTH_ERROR_ACCESS_DENIED;
}
-#endif
switch (discoverable_mode) {
case BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE:
/* TODO: Cleanup bluetooth profiles */
_bt_hidhost_deinitialize();
_bt_socket_deinit();
-#if 0
- /* TODO: Cleanup bluetooth audio profiles */
+
+ /* TODO: Cleanup bluetooth audio profiles
//_bt_audio_deinitialize(BT_A2DP_SOURCE_MODULE);
//_bt_audio_deinitialize(BT_AVRCP_MODULE);
//_bt_audio_deinitialize(BT_A2DP_SINK_MODULE);
//_bt_audio_deinitialize(BT_AUDIO_ALL_MODULE);
a2dp_init_pending = TRUE;
-#endif
+ */
_bt_hdp_deinit();
_bt_gatt_deinit();
if (vconf_get_int(VCONFKEY_BT_STATUS, &status) != 0)
BT_ERR("Fail to get the enabled value");
-#if 0
- /* Update Bluetooth Status to OFF */
- if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
- BT_ERR("Set vconf failed\n");
-#endif
-
if (status & VCONFKEY_BT_STATUS_ON) {
ret = _bt_enable_adapter();
if (ret != BLUETOOTH_ERROR_NONE)
_bt_device_handle_adapter_state(FALSE);
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
/* Send the information to Absolute Volume Controller */
_bt_audio_handle_adapter_disabled();
-#endif
/* Update the vconf BT status in normal Deactivation case only */
ret = vconf_get_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, &power_off_status);
static void __bt_set_visible_mode(void)
{
int timeout = 0;
-#ifdef TIZEN_FEATURE_BT_DPM
int discoverable_state = DPM_BT_ERROR;
-#endif
if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
BT_ERR("Fail to get the timeout value");
-#ifdef TIZEN_FEATURE_BT_DPM
_bt_dpm_get_bluetooth_limited_discoverable_state(&discoverable_state);
if (timeout == -1 || discoverable_state == DPM_RESTRICTED) {
if (_bt_set_discoverable_mode(
BT_ERR("Set vconf failed");
}
}
-#else
- if (timeout == -1) {
- if (_bt_set_discoverable_mode(
- BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
- timeout) != BLUETOOTH_ERROR_NONE) {
- if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
- BT_ERR("Set vconf failed");
- }
- }
-#endif
}
static void __bt_set_local_name(void)
* But if Tizen supports a device with A2DP Sink and HFP both profiles (BT_AUDIO_HFP_SOURCE)
* then below logic will be required for corresponding connect/disconnect function
*/
-#if 0
+/*
req_info = _bt_get_request_info_data(BT_AUDIO_CONNECT, addr);
if (req_info == NULL) {
BT_INFO("Audio Connect All request is also Not found..");
BT_INFO("Pending connect is Not found..");
}
}
-#endif
+*/
goto check_wait_device;
} else {
BT_ERR("AV Connect request has failed.."); /* DBUS return needed */
/* Add data from the connected list */
_bt_add_headset_to_list(BT_AUDIO_A2DP, BT_STATE_CONNECTED, addr);
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
/* Send the information to Absolute Volume Controller */
_bt_audio_handle_a2dp_state_changed(addr, true);
-#endif
/* Delete waiting device data if present */
wait_device = _bt_get_audio_wait_data();
/* Remove data from the connected list */
_bt_remove_headset_from_list(BT_AUDIO_A2DP, addr);
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
/* Send the information to Absolute Volume Controller */
_bt_audio_handle_a2dp_state_changed(addr, false);
-#endif
_bt_connection_manager_set_state(addr, BLUETOOTH_EVENT_AV_DISCONNECTED);
static void __handle_transport_property_volume(unsigned int avrcp_volume)
{
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
_bt_audio_handle_transport_volume_changed(avrcp_volume);
-#endif
}
static void __handle_avrcp_connection_event(int event, bt_address_t *bdaddr)
#include "bt-service-event.h"
#include "bt-service-avrcp-tg.h"
-/* We will remove this flag after stabilizing the functionality */
-#define AVC_DEBUG 1
-
/* Avoid the build error related to vconf.h's dependency */
#ifndef VCONFKEY_BT_AVC_MODE
#define VCONFKEY_BT_AVC_MODE "db/bluetooth/avc_mode"
if (*bt_vol > 0 && *bt_vol < 127)
*bt_vol = *bt_vol + 1;
-#ifdef AVC_DEBUG
BT_DBG("System volume [%d], BT volume [%d]", sys_vol, *bt_vol);
-#endif
}
static void __bt_audio_covert_bt_to_system_volume(unsigned int bt_vol, unsigned int *sys_vol)
if (*sys_vol > 0 && *sys_vol < 150)
*sys_vol = *sys_vol + 1;
-#ifdef AVC_DEBUG
BT_DBG("System volume [%d], BT volume [%d]", *sys_vol, bt_vol);
-#endif
}
static int __bt_audio_get_active_headset_volume(void)
gboolean connected = FALSE;
unsigned int volume = BT_VOLUME_MAX + 1;
-#ifdef AVC_DEBUG
- BT_DBG("+");
-#endif
-
/* 1. Get active A2DP headset path */
/* We should modify this function to get the active headset in later */
int _bt_audio_init_absolute_volume_control(void)
{
-#ifdef AVC_DEBUG
- BT_DBG("+");
-#endif
-
absolute_volume = ABSOLUTE_VOLUME_MAX + 1;
bt_volume = BT_VOLUME_MAX + 1;
avc_mode = BT_AVC_OFF;
void _bt_audio_deinit_absolute_volume_control(void)
{
-#ifdef AVC_DEBUG
- BT_DBG("+");
-#endif
-
absolute_volume = ABSOLUTE_VOLUME_MAX + 1;
bt_volume = BT_VOLUME_MAX + 1;
avc_mode = BT_AVC_OFF;
*volume = absolute_volume;
-#ifdef AVC_DEBUG
BT_DBG("volume: %d", *volume);
-#endif
return BLUETOOTH_ERROR_NONE;
}
*activated = (mode == BT_AVC_OFF) ? false : true;
-#ifdef AVC_DEBUG
BT_DBG("avc_mode: %d", avc_mode);
-#endif
return BLUETOOTH_ERROR_NONE;
}
int state = 0;
int volume = 0;
-#ifdef AVC_DEBUG
- BT_DBG("+");
-#endif
-
/* 1. Get AVC mode in the vconf value */
if (vconf_get_bool(VCONFKEY_BT_AVC_MODE, &state) != 0) {
BT_ERR("vconf_get_bool failed");
{
unsigned int mode = 0;
-#ifdef AVC_DEBUG
- BT_DBG("+");
-#endif
-
/* In later, we can check the event for the active headset or not in here */
if (connected == false) {
int mode = BT_AVC_OFF;
unsigned int prev_vol = absolute_volume;
-#ifdef AVC_DEBUG
- BT_DBG("+");
-#endif
-
if (bt_vol > BT_VOLUME_MAX) {
/* BT AVC mode off, because bluez transport initiate the volue as MAX */
absolute_volume = ABSOLUTE_VOLUME_MAX + 1;
#include "bt-service-mesh-network.h"
#include "bt-service-mesh-config-client.h"
#include "bt-service-mesh-model.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
-#endif
#include "bt-service-hidhost.h"
#include "bt-service-rfcomm.h"
#include "bt-service-hdp.h"
" <arg type='i' name='output_param1' direction='out' />"
" <arg type='v' name='output_param2' direction='out' />"
" </method>"
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
" <method name='get_avc_mode'>"
/* Out Parameters */
" <arg type='u' name='avc_mode' direction='out' />"
" </method>"
-#endif
" </interface>"
"</node>";
|| service_function == BT_START_LE_DISCOVERY
|| service_function == BT_STOP_LE_DISCOVERY
|| service_function == BT_GET_CONNECTABLE
-#ifdef TIZEN_GATT_CLIENT
|| service_function == BT_GATT_CLIENT_REGISTER
|| service_function == BT_GATT_GET_PRIMARY_SERVICES
|| service_function == BT_GATT_GET_SERVICE_PROPERTIES
|| service_function == BT_GATT_GET_CHARACTERISTIC_PROPERTIES
|| service_function == BT_GATT_WATCH_CHARACTERISTIC
|| service_function == BT_GATT_ACQUIRE_WRITE
-#endif
|| service_function == BT_AUDIO_SELECT_ROLE
/* Mesh API's */
|| service_function == BT_MESH_NETWORK_CREATE
g_variant_unref(param4);
g_variant_unref(param5);
}
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
else if (g_strcmp0(method_name, "get_avc_mode") == 0) {
unsigned int mode = 0;
g_dbus_method_invocation_return_value(invocation,
g_variant_new("(u)", mode));
}
-#endif
FN_END;
return;
}
break;
}
-#ifdef TIZEN_FEATURE_BT_DPM
case BT_DPM_SET_ALLOW_BT_MODE: {
dpm_bt_allow_t value = DPM_BT_ERROR;
g_array_append_vals(*out_param1, &value, sizeof(int));
break;
}
-#endif
case BT_RFCOMM_CLIENT_CONNECT: {
bluetooth_device_address_t address = { {0} };
char *input_string;
}
break;
}
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
case BT_AUDIO_SET_ABSOLUTE_VOLUME: {
unsigned int volume = 0;
g_array_append_vals(*out_param1, &activated, sizeof(bool));
break;
}
-#endif
case BT_AV_CONNECT: {
bluetooth_device_address_t address = { {0} };
__bt_service_get_parameters(in_param1,
break;
}
-#ifdef TIZEN_GATT_CLIENT
/* Local Async */
case BT_GATT_CLIENT_REGISTER: {
bluetooth_device_address_t address = { {0} };
parameters.timeout);
break;
}
-#endif
case BT_START_LE_DISCOVERY: {
uid_t uid = 0;
pid_t pid = 0;
case BT_AVRCP_SET_PROPERTIES:
case BT_AVRCP_CONTROL_SET_PROPERTY:
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
case BT_AUDIO_SET_ABSOLUTE_VOLUME:
case BT_AUDIO_GET_ABSOLUTE_VOLUME:
case BT_AUDIO_IS_AVC_ACTIVATED:
-#endif
case BT_HF_CONNECT:
case BT_HF_DISCONNECT:
case BT_NETWORK_SERVER_DISCONNECT:
case BT_GATT_GET_PRIMARY_SERVICES:
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_GET_SERVICE_PROPERTIES: /* GATT Client */
case BT_GATT_GET_CHARACTERISTIC_PROPERTIES: /* GATT Client */
case BT_GATT_WATCH_SERVICE_CHANGED_INDICATION: /* GATT Client */
-#endif
case BT_GATT_DISCOVER_CHARACTERISTICS:
case BT_GATT_SET_PROPERTY_REQUEST:
case BT_GATT_READ_CHARACTERISTIC:
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_READ_DESCRIPTOR_VALUE: /* GATT Client */
case BT_GATT_WRITE_CHARACTERISTIC_VALUE_BY_TYPE: /* GATT Client */
case BT_GATT_ACQUIRE_WRITE:
case BT_GATT_WATCH_CHARACTERISTIC: /* GATT Client */
case BT_GATT_CLIENT_REGISTER: /* GATT Client */
case BT_GATT_CLIENT_UNREGISTER: /* GATT Client */
-#endif
case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
case BT_GATT_REGISTER_APPLICATION:
case BT_GATT_REGISTER_SERVICE:
return NULL;
}
-#ifdef TIZEN_GATT_CLIENT
invocation_info_t* _bt_get_request_info_data_from_function_name(int service_function)
{
GSList *l;
BT_DBG("Not existed");
return NULL;
}
-#endif
void _bt_set_device_values(gboolean connected, int state)
{
* limitations under the License.
*
*/
-#ifdef TIZEN_FEATURE_BT_DPM
-
#include <glib.h>
#include <gio/gio.h>
#include <dlog.h>
{
BT_INFO("_bt_dpm_set_allow_bluetooth_mode");
-#if 0
- if (value == DPM_BT_ALLOWED && value == DPM_BT_HANDSFREE_ONLY) {
- /* Update Bluetooth DPM Status to notify other modules */
- if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0)
- BT_ERR("Set vconf failed\n");
- return DPM_RESULT_FAIL;
- } else {
- /* Update Bluetooth DPM Status to notify other modules */
- if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, VCONFKEY_BT_DPM_STATUS_RESTRICTED) != 0)
- BT_ERR("Set vconf failed\n");
- return DPM_RESULT_FAIL;
- }
-#endif
policy_table[DPM_POLICY_ALLOW_BLUETOOTH].value = value;
return BLUETOOTH_ERROR_NONE;
policy_table[DPM_POLICY_BLUETOOTH_UUIDS_BLACKLIST].list = g_slist_append(policy_table[DPM_POLICY_BLUETOOTH_UUIDS_BLACKLIST].list, l_uuid);
-#if 0 /* Use device functions if this logic required in later */
+ /* Use device functions if this logic required in later */
/* Disconnect if connected blacklist uuid is existing */
+ /*
addr_list = g_array_new(FALSE, FALSE, sizeof(gchar));
_bt_get_profile_connected_devices((char *)uuid, &addr_list);
for (i = 0; i < (addr_list->len / sizeof(bluetooth_device_address_t)); i++) {
// TODO: need to implement disconnect logic
}
g_array_free(addr_list, TRUE);
-#endif
+ */
return BLUETOOTH_ERROR_NONE;
}
dpm_profile_state[profile].value = value;
-#if 0 /* Use other functions if this logic required in later */
+ /* Use other functions if this logic required in later */
/* In case of restriction, disconnect if connected profile is existing */
+ /*
if (value == DPM_RESTRICTED) {
char *uuid = NULL;
GArray *addr_list = NULL;
}
g_array_free(addr_list, TRUE);
}
-#endif
+ */
return BLUETOOTH_ERROR_NONE;
}
return err;
}
-#endif /* #ifdef TIZEN_FEATURE_BT_DPM */
BT_INFO("Device properties received, Audio callback registered, call it...");
audio_event_cb(event_type, event_data);
}
-#if 0
- if (hid_cb)
- hid_cb(event_type, event_data);
-#endif
if (device_cb)
device_cb(event_type, event_data);
break;
if (adapter_le_cb)
adapter_le_cb(event_type, event_data);
break;
-#ifdef TIZEN_GATT_CLIENT
case OAL_EVENT_GATTC_DISCONNECTION_COMPLETED:
case OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT:
case OAL_EVENT_GATTC_SERVICE_SEARCH_DONE:
if (adapter_le_cb)
adapter_le_cb(event_type, event_data);
break;
-#endif
case OAL_EVENT_BLE_DISCOVERY_STARTED:
case OAL_EVENT_BLE_DISCOVERY_STOPPED:
case OAL_EVENT_BLE_DISCOVERY_FINISHED:
path = BT_GATT_SERVER_PATH;
break;
#endif
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_CLIENT_EVENT:
path = BT_GATT_CLIENT_PATH;
break;
-#endif
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
case BT_AUDIO_AVC_EVENT:
path = BT_AUDIO_AVC_PATH;
break;
-#endif
+
case BT_MESH_EVENT:
path = BT_MESH_PATH;
break;
case BLUETOOTH_EVENT_AVRCP_VOLUME_CHANGED:
signal = BT_MEDIA_VOLUME_CHANGE;
break;
-#ifdef TIZEN_GATT_CLIENT
case BLUETOOTH_EVENT_GATT_SERVER_CONNECTED: /* GATT Server and Client */
signal = BT_GATT_SERVER_CONNECTED;
BT_INFO_C("### Connected [GATT server]");
signal = BT_GATT_CLIENT_DISCONNECTED;
BT_INFO_C("### Disconnected [GATT client]");
break;
-#else
- case BLUETOOTH_EVENT_GATT_CONNECTED:
- signal = BT_GATT_CONNECTED;
- BT_INFO_C("### Connected [GATT]");
- break;
- case BLUETOOTH_EVENT_GATT_DISCONNECTED:
- signal = BT_GATT_DISCONNECTED;
- BT_INFO_C("### Disconnected [GATT]");
- break;
-#endif
case BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED:
signal = BT_GATT_REQ_ATT_MTU_CHANGED;
break;
signal = BT_GATT_SERVER_ACQUIRE_NOTIFICATION;
break;
#endif
-#ifdef TIZEN_GATT_CLIENT
case BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED: /* GATT Client */
signal = BT_GATT_CLIENT_SERVICE_CHANGED;
break;
-#endif
-
case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED:
signal = BT_IPSP_INITIALIZED;
break;
case BLUETOOTH_EVENT_OTC_STATE_CHANGED:
signal = BT_OTC_STATE_CHANGED;
break;
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
case BLUETOOTH_EVENT_AUDIO_AVC_MODE_CHANGED:
signal = BT_AUDIO_AVC_MODE_CHANGED;
break;
-#endif
/* Mesh events */
case BLUETOOTH_EVENT_MESH_SCAN_STARTED:
signal = BT_MESH_SCAN_STARTED;
case BT_HDP_EVENT:
path = BT_HDP_DEVICE_PATH;
break;
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_CLIENT_EVENT:
path = BT_GATT_CLIENT_PATH;
break;
-#endif
default:
BT_ERR("Unknown event");
return BLUETOOTH_ERROR_INTERNAL;
case BLUETOOTH_EVENT_HDP_DISCONNECTED:
signal = BT_HDP_DISCONNECTED;
break;
-#ifdef TIZEN_GATT_CLIENT
case BLUETOOTH_EVENT_GATT_READ_CHAR: /* GATT Client */
signal = BT_GATT_CLIENT_READ_CHAR;
break;
case BLUETOOTH_EVENT_GATT_WRITE_DESC: /* GATT Client */
signal = BT_GATT_CLIENT_WRITE_DESC;
break;
-#endif
-
default:
BT_ERR("Unknown event");
return BLUETOOTH_ERROR_INTERNAL;
static void __bt_release_service(void)
{
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
_bt_audio_deinit_absolute_volume_control();
-#endif
_bt_service_le_deinit();
_bt_deinit_hf_local_term_event_sender();
int bt_le_status = VCONFKEY_BT_LE_STATUS_OFF;
int flight_mode_deactivation = 0;
int bt_off_due_to_timeout = 0;
-#if 0
- int ps_mode_deactivation = 0;
-#endif
if (_is_name_acquired() == FALSE) {
BT_ERR("dbus name is NOT acquired yet");
}
if (TIZEN_PROFILE_TV) {
-#if TODO_40 /* Need to add this function */
+/*
+#if TODO_40
if (_bt_get_enable_timer_id() == 0)
#endif
+*/
_bt_enable_adapter();
} else if (!headed_plugin_info->plugin_headed_enabled) {
BT_DBG("Enable adapter if headless device");
if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &flight_mode_deactivation) != 0)
BT_ERR("Fail to get the flight_mode_deactivation value");
-#if 0
- if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, &ps_mode_deactivation) != 0)
- BT_ERR("Fail to get the ps_mode_deactivation value");
-#endif
-
if (vconf_get_int(BT_OFF_DUE_TO_TIMEOUT, &bt_off_due_to_timeout) != 0)
BT_ERR("Fail to get BT_OFF_DUE_TO_TIMEOUT");
_bt_init_request_list();
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
ret = _bt_audio_init_absolute_volume_control();
if (ret != BLUETOOTH_ERROR_NONE)
BT_ERR("Fail to init AVC");
-#endif
is_initialized = TRUE;
#include "bt-service-device-internal.h"
#include "bt-service-event.h"
#include "bt-service-event-receiver.h"
-#ifdef TIZEN_GATT_CLIENT
#include "bt-service-gatt.h"
-#endif
#include "bt-service-headset-connection.h"
#include "bt-service-main.h"
#ifdef TIZEN_MDM_ENABLE
static int dbfw_rssi;
-#ifdef TIZEN_GATT_CLIENT
typedef struct {
char *address;
float interval_min;
#define BT_LE_CONN_INTERVAL_SPLIT 1.25 /* msec */
static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected);
-#endif
/* Forward declaration */
static void __bt_device_event_handler(int event_type, gpointer event_data);
/* Update local cache */
_bt_update_remote_dev_property(address, DEV_PROP_CONNECTED, (void *)&conn_info);
-#ifdef TIZEN_GATT_CLIENT
/*handle LE connected device info*/
if (type)
_bt_handle_le_connected_dev_info(address, connected);
-#endif
-
}
static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble)
case BT_PROFILE_CONN_HFG:
svc_id = HFP_SERVICE_ID; /* Remote is HFP AG Unit */
break;
-#ifdef TIZEN_GATT_CLIENT
case BT_PROFILE_CONN_GATT:
return _bt_is_remote_gatt_device_connected(device_address); /* Remote is GATT client or Server */
-#endif
default:
BT_DBG("Unknown svc_type: %d", svc_type);
return FALSE;
return result;
}
-#ifdef TIZEN_GATT_CLIENT
static bt_connected_le_dev_t *__bt_get_le_connected_dev_info(const char *address)
{
GSList *l = NULL;
return FALSE;
}
-#endif
#include "bt-service-gatt.h"
#include "bt-service-core-device.h"
#include "bt-service-core-adapter-le.h"
-#ifdef TIZEN_GATT_CLIENT
#include "bluetooth-gatt-client-api.h"
-#endif
#include <oal-hardware.h>
#include <oal-manager.h>
#define BT_SENDER_MAX_LENGTH 50
#define MAX_APPS_SUPPORTED 11 /* Slot 0 is not used */
#define BT_DEFAULT_ATT_MTU 23
-
-#ifdef TIZEN_GATT_CLIENT
#define NUM_UUID 20
-#else
-#define NUM_UUID 10
-#endif
-
-
#define UUID_MAX_LEN 50
-
#define BDADDR_ANY (&(bluetooth_device_address_t) {{0, 0, 0, 0, 0, 0} })
-#ifdef TIZEN_GATT_CLIENT
static char uuid_list[NUM_UUID][BT_UUID_STRING_MAX] = {"0000b00b-0000-0000-f065-080080fa49b5", /* Used by BLEAPP */
"0000b00b-1111-1111-0123-456789ab0cd2", /* Used by BLEAPP */
"0000b00b-2222-1111-0123-456789ab0cd2",
"0000b00c-1111-1111-0123-456789ab0cd2",
"0000b00c-2222-1111-0123-456789ab0cd2",
"0000b00c-3333-1111-0123-456789ab0cd2"};
-#else
-static char uuid_list[NUM_UUID][BT_UUID_STRING_MAX] = {"0000b00b-0000-0000-f065-080080fa49b5", /* Used by BLEAPP */
- "0000b00b-1111-1111-0123-456789ab0cd2", /* Used by BLEAPP */
- "0000b00b-2222-1111-0123-456789ab0cd2",
- "0000b00b-3333-1111-0123-456789ab0cd2",
- "0000b00b-4444-1111-0123-456789ab0cd2",
- "0000b00b-5555-1111-0123-456789ab0cd2",
- "0000b00b-6666-1111-0123-456789ab0cd2",
- "0000b00b-7777-1111-0123-456789ab0cd2",
- "0000b00b-8888-1111-0123-456789ab0cd2",
- "0000b00b-9999-1111-0123-456789ab0cd2"};
-#endif
-#ifdef TIZEN_GATT_CLIENT
/* Reserved GATT client Instance UUID. This is used only internally by bt-service */
#define DEFAULT_GATT_CLIENT_UUID "0000a00a-1111-1111-0123-456789abcdef"
} bt_gatt_included_service_info_t;
static GSList *list_gatt_info = NULL;
-#endif
/* App Information structure */
typedef struct {
int scan_rsp_len;
gboolean is_initialized;
GSList *service_handles;
-#ifdef TIZEN_GATT_CLIENT
int client_id; /* GATT Client instance ID */
bluetooth_device_address_t address; /* Remote BLE Device Address */
gboolean is_watcher_enabled;
-#endif
} bt_service_app_info_t;
/* GATT Server Request Info Structure */
static void __bt_service_reset_gatt_data(void);
-#ifdef TIZEN_GATT_CLIENT
static void __bt_handle_client_instance_registered(event_gattc_register_t *data);
static void __bt_handle_client_connected(event_gattc_conn_t *event_data);
static void __bt_handle_client_disconnected(event_gattc_conn_t *event_data);
static void __bt_handle_client_notification_data(event_gattc_notify_data *event_data);
static void __bt_handle_client_service_changed_ind(event_gattc_service_changed_data *event_data);
static void __bt_handle_client_mtu_exchange_completed(event_gattc_mtu_configured_t *event_data);
-#endif
static int __bt_unregister_gatt_server_instance(int server_instance);
static void __bt_cleanup_remote_services(struct gatt_server_info_t *conn_info);
}
}
-#ifdef TIZEN_GATT_CLIENT
char * _bt_gatt_get_default_gatt_client_uuid(void)
{
return g_strdup(DEFAULT_GATT_CLIENT_UUID);
g_free(uuid_str);
}
-#endif
int _bt_gatt_init(void)
{
/* Exact matching of Adv handle + sender combination */
if (!g_strcmp0(info->sender, sender) && info->adv_handle == adv_handle)
return info->instance_id;
-#if 0
+/*
if (!g_strcmp0(info->sender, sender) && info->adv_handle == -1)
return info->instance_id;
-#endif
+*/
}
return -1;
}
#endif
case BT_CONNECT_LE:
case BT_DISCONNECT_LE: {
-#ifdef TIZEN_GATT_CLIENT
char *addr = (char*)req_info->user_data;
bluetooth_device_address_t address;
_bt_free_info_from_invocation_list(req_info);
g_array_free(out_param, TRUE);
}
-#else
- out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
-
- g_array_append_vals(out_param, (bluetooth_device_address_t*)data,
- sizeof(bluetooth_device_address_t));
- _bt_service_method_return(req_info->context, out_param, result);
-
- _bt_free_info_from_invocation_list(req_info);
-
- g_array_free(out_param, TRUE);
-#endif
break;
}
-#ifdef TIZEN_GATT_CLIENT
case BT_GATT_CLIENT_REGISTER: {
bt_service_app_info_t *param = (bt_service_app_info_t*)data;
g_array_free(out_param, TRUE);
}
}
-#endif
default:
break;
}
return NULL;
}
-#ifdef TIZEN_GATT_CLIENT
struct gatt_server_info_t *_bt_find_remote_gatt_server_info(char *address)
{
GSList *l;
}
return NULL;
}
-#endif
-#ifdef TIZEN_GATT_CLIENT
static void __bt_handle_gatt_server_connection_state(event_gatts_conn_t *event)
{
int result = BLUETOOTH_ERROR_NONE;
__bt_remove_mtu_gatt_device(address);
}
-#else
-
-static void __bt_handle_gatt_server_connection_state(event_gatts_conn_t *event)
-{
- int result = BLUETOOTH_ERROR_NONE;
- struct gatt_client_info_t *conn_info = NULL;
- bt_service_app_info_t *info = NULL;
- bluetooth_device_address_t dev_addr;
- GVariant *param = NULL;
- int k;
-
- char *address = g_malloc0(BT_ADDRESS_STRING_SIZE);
-
- memcpy(dev_addr.addr, event->address.addr, 6);
-
-
- /* Check if the just registered Instance ID belongs to BLEAPP or GATT Server */
- for (k = 1; k < MAX_APPS_SUPPORTED; k++) {
- info = &numapps[k];
-
- if (info->instance_id == event->server_inst) {
- BT_INFO("Found GATT Server.. UUID [%s], sender [%s]", info->uuid, info->sender);
- __bt_gatt_handle_pending_request_info(result, BT_CONNECT_LE,
- (bluetooth_device_address_t*)&dev_addr, sizeof(bluetooth_device_address_t));
-
- break;
- }
- }
-
- /* Send event to BT-API */
- _bt_convert_addr_type_to_string(address,
- (unsigned char *)dev_addr.addr);
-
- BT_INFO("GATT Server Connedted: Remote Client addr[%s] Server Instance [%d] Connection ID [%d]",
- address, event->server_inst, event->conn_id);
-
-
- /* Check if device is already in connected list */
- conn_info = _bt_find_remote_gatt_client_info(address);
-
- if (!conn_info) {
- param = g_variant_new("(is)", result, address);
- /* Send event to application */
- _bt_send_event(BT_GATT_SERVER_EVENT,
- BLUETOOTH_EVENT_GATT_CONNECTED,
- param);
-
- /* Save Connection info */
- conn_info = g_new0(struct gatt_client_info_t, 1);
- conn_info->addr = g_strdup(address);
- BT_INFO("Added GATT client addr[%s]", conn_info->addr);
- conn_info->connection_id = event->conn_id;
- conn_info->instance_id = event->server_inst;
- gatt_client_info_list = g_slist_append(gatt_client_info_list, conn_info);
- BT_INFO("Total num of connected GATT clients [%d]", g_slist_length(gatt_client_info_list));
- }
-
- g_free(address);
-}
-
-/* GATT Server Dis connected */
-static void __bt_handle_gatt_server_disconnection_state(event_gatts_conn_t *event)
-{
- int result = BLUETOOTH_ERROR_NONE;
- struct gatt_client_info_t *conn_info = NULL;
- bluetooth_device_address_t dev_addr;
- bt_service_app_info_t *info = NULL;
- GVariant *param = NULL;
- int k;
-
- char *address = g_malloc0(BT_ADDRESS_STRING_SIZE);
-
- memcpy(dev_addr.addr, event->address.addr, 6);
-
- /* Check if the just registered Instance ID belongs to BLEAPP or GATT Server */
- for (k = 1; k < MAX_APPS_SUPPORTED; k++) {
- info = &numapps[k];
-
- if (info->instance_id == event->server_inst) {
- BT_INFO("Found GATT Server.. UUID [%s], sender [%s]", info->uuid, info->sender);
- __bt_gatt_handle_pending_request_info(result, BT_DISCONNECT_LE,
- (bluetooth_device_address_t*)&dev_addr, sizeof(bluetooth_device_address_t));
-
- break;
- }
- }
-
- /* Send event to BT-API */
- _bt_convert_addr_type_to_string(address,
- (unsigned char *)dev_addr.addr);
-
- BT_INFO("GATT Server DisConnected: Remote Client addr[%s] Server Instance [%d] Connection ID [%d]",
- address, event->server_inst, event->conn_id);
-
- param = g_variant_new("(is)", result, address);
- /* Send event to application */
- _bt_send_event(BT_GATT_SERVER_EVENT,
- BLUETOOTH_EVENT_GATT_DISCONNECTED,
- param);
-
- /* Remove Connection info */
- conn_info = _bt_find_remote_gatt_client_info(address);
- if (conn_info) {
- BT_INFO("Remove GATT client info from List..");
- /* Remove info from List */
- gatt_client_info_list = g_slist_remove(gatt_client_info_list, conn_info);
- BT_INFO("Total num of connected GATT clients [%d]", g_slist_length(gatt_client_info_list));
- g_free(conn_info->addr);
- g_free(conn_info);
- }
-
- g_free(address);
-}
-#endif
-
static void __bt_handle_gatt_server_acquire_write_requested(event_gatts_srvc_acquire_attr_t *event)
{
__bt_handle_gatt_mtu_changed_event((event_gatts_mtu_changed_t *)event_data);
break;
}
-#ifdef TIZEN_GATT_CLIENT
case OAL_EVENT_GATTC_REGISTRATION: {
BT_INFO("OAL Event: GATT Client instance Registered");
__bt_handle_client_instance_registered((event_gattc_register_t *) event_data);
__bt_handle_client_mtu_exchange_completed((event_gattc_mtu_configured_t *) event_data);
break;
}
-#endif
default:
BT_DBG("Unhandled OAL event = 0x%x", event_type);
break;
return BLUETOOTH_ERROR_NONE;
}
-#ifdef TIZEN_GATT_CLIENT
/* GATT Client utility static functions */
static bt_gatt_service_info_list_t *__bt_get_service_info_list(int conn_id)
{
BT_DBG("Total num of connected Remote GATT server devices [%d]",
g_slist_length(gatt_server_info_list));
-#if 0
+/*
BT_INFO("Do a Internal refresh");
if (OAL_STATUS_SUCCESS != gattc_refresh(conn_info->client_id, &event_data->address))
BT_ERR("GATT database refresh failed!!");
else
BT_INFO("GATT database refresh Success!!");
-#endif
+*/
} else
BT_ERR("Local GATT Client connected event for addr[%s], but device is in connected list already", address);
return BLUETOOTH_ERROR_NONE;
}
-
-#endif
void _bt_audio_handle_incoming_authorization(char *address, int service_id);
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
typedef enum {
BT_AVC_OFF = 0x00,
BT_AVC_NULL,
void _bt_audio_handle_a2dp_state_changed(const char *address, bool connected);
void _bt_audio_handle_transport_volume_changed(unsigned int bt_vol);
-#endif
int _bt_hf_connect(bluetooth_device_address_t *device_address);
extern "C" {
#endif
-#if 0
-
-#define BT_MEDIA_OBJECT_PATH "/Musicplayer"
-
-#define BT_AVRCP_ERROR (__bt_avrcp_error_quark())
-
-#define BT_ERROR_INTERNAL "InternalError"
-#define BT_ERROR_INVALID_PARAM "InvalidParameters"
-#define BT_ERROR_INVALID_INTERFACE "InvalidInterface"
-
-typedef enum {
- BT_AVRCP_ERROR_NONE,
- BT_AVRCP_ERROR_INTERNAL,
- BT_AVRCP_ERROR_INVALID_PARAM,
- BT_AVRCP_ERROR_NOT_SUPPORTED,
- BT_AVRCP_ERROR_INVALID_INTERFACE
-} bt_avrcp_error_t;
-
-int _bt_register_media_player(void);
-
-int _bt_unregister_media_player(void);
-#endif
-
int _bt_avrcp_connect_remote_ctrl(bluetooth_device_address_t *address);
int _bt_avrcp_disconnect_remote_ctrl(bluetooth_device_address_t *address);
char *manufacturer_data;
int manufacturer_data_len;
guchar addr_type;
-#if 0 /* Should match with bt_dev_info_t in bluetooth-api.h */
- bt_remote_le_dev_info_t le_dev_info;
-#endif
+
int vid;
int pid;
int device_type;
gboolean _bt_is_device_creating(void);
-#ifdef TIZEN_GATT_CLIENT
int _bt_le_connection_update(const char *sender,
unsigned char *device_address,
float interval_min, float interval_max,
guint16 latency, guint16 time_out);
-#endif
#ifdef TIZEN_FEATURE_BT_OBEX
bluetooth_trusted_profile_t _bt_get_trusted_profile_enum(const char *uuid);
* limitations under the License.
*
*/
-#ifdef TIZEN_FEATURE_BT_DPM
-
#ifndef _BT_SERVICE_DPM_H_
#define _BT_SERVICE_DPM_H_
}
#endif /* __cplusplus */
#endif /*_BT_SERVICE_DPM_H_*/
-#endif /* #ifdef TIZEN_FEATURE_BT_DPM */
#include <sys/types.h>
#include "bluetooth-api.h"
#include "bluetooth-gatt-server-api.h"
-
-#ifdef TIZEN_GATT_CLIENT
#include "bluetooth-gatt-client-api.h"
-#endif
#ifdef __cplusplus
extern "C" {
struct gatt_conn_info_t *_bt_find_remote_gatt_client_info(char *address);
#endif
-#ifdef TIZEN_GATT_CLIENT
char * _bt_gatt_get_default_gatt_client_uuid(void);
int _bt_register_gatt_client_instance(const char *sender,
struct gatt_conn_info_t *_bt_find_remote_gatt_server_info(char *address);
#endif
-#endif
-//int _bt_gatt_server_enable_application(int instance_id);
-#if 0
-int _bt_gatt_server_register(char *sender);
-
-int _bt_gatt_server_unregister(char *sender);
-
-int _bt_gatt_server_update_multi_adv_info(char *name, int instance_id);
-
-int _bt_gatt_server_connect_remote_client(char *sender,
- bluetooth_device_address_t *address, int instance_id);
-
-int _bt_gatt_server_disconnect_remote_client(char *sender,
- bluetooth_device_address_t *address,
- int instance_id);
-
-int _bt_gatt_server_add_service(char *sender, int service_type,
- int num_handles, char *svc_uuid, int instance_id);
-
-int _bt_gatt_server_add_included_service(char *sender, int instance_id,
- int service_handle, int included_svc_handle);
-
-int _bt_gatt_server_add_characteristic(char *sender, char *char_uuid,
- bluetooth_gatt_server_attribute_params_t *param);
-
-int _bt_gatt_server_add_descriptor(char *sender, char *desc_uuid,
- bt_gatt_permission_t *perm, int service_handle, int instance_id);
-
-int _bt_gatt_server_start_service(char *sender, int service_handle, int instance_id);
-
-int _bt_gatt_server_stop_service(char *sender, int service_handle, int instance_id);
-
-int _bt_gatt_server_delete_service(char *sender, int service_handle, int instance_id);
-
-int _bt_gatt_server_send_indication(char *sender, bluetooth_device_address_t *addr, bluetooth_gatt_att_data_t *data,
- bluetooth_gatt_server_indication_params_t *param);
-
-int _bt_gatt_server_send_response(char *sender, bluetooth_gatt_att_data_t *data,
- bluetooth_gatt_server_response_params_t *param);
-
-void _bt_gatt_server_clear_req_info(void);
-
-void _bt_gatt_server_clear_connection_info(void);
-
-bt_product_gatt_permission_t _bt_gatt_convert_attr_permission_to_stack_specific(
- bt_gatt_permission_t perm);
-
-void _bt_check_gatt_server_app_termination(const char *name);
-
-int _bt_gatt_server_get_att_mtu(bluetooth_device_address_t *address, unsigned int *mtu);
-
-#endif
-
#ifdef __cplusplus
}
#endif /* __cplusplus */
static inline void stack_trim(void)
{
+/*
#ifdef STACK_FLUSH
unsigned int sp;
char buf[BUF_SIZE];
perror("stack madvise fail");
}
#endif
+*/
}
#endif /* __STACKTRIM_H__ */
#include "bt-service-core-adapter.h"
#include "bt-service-core-adapter-le.h"
#include "bt-service-device.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
-#endif
#define BT_MEDIA_OBJECT_PATH "/Musicplayer"
static GDBusConnection *manager_conn;
#include "bt-service-opp-client.h"
#include "bt-service-map-client.h"
#include "bt-service-core-adapter.h"
-
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
-#endif
#define DBUS_TIMEOUT 20 * 1000 /* 20 Sec */
static GDBusConnection *manager_conn;
This code will be removed and moved to OAL Event Handling part .
*/
-#if 0
-static void __bt_get_uuids(GVariant *value, bt_remote_dev_info_t *info)
-{
- ret_if(value == NULL);
- ret_if(info == NULL);
-
- gsize uuid_count = 0;
-
- info->uuids = g_variant_dup_strv(value, &uuid_count);
- info->uuid_count = (unsigned int)uuid_count;
-
- BT_DBG("uuid count : %d", uuid_count);
-}
-#endif
-
void _bt_convert_addr_string_to_secure_string(char *addr,
const char *address)
{
#include <dlog.h>
#include <string.h>
#include <dirent.h>
-#ifdef TIZEN_FEATURE_BT_DPM
#include "bt-service-dpm.h"
-#endif
#include <vconf.h>
GVariant *param = NULL;
GError *err = NULL;
bt_session_info_t *session_info = NULL;
-#ifdef TIZEN_FEATURE_BT_DPM
int value = DPM_BT_ERROR;
-#endif
BT_DBG(" path [%s] \n", path);
agent_info.auth_info->transfer_path = g_strdup(path);
-#ifdef TIZEN_FEATURE_BT_DPM
_bt_dpm_get_allow_bluetooth_mode(&value);
if (value == DPM_BT_HANDSFREE_ONLY) {
/* Free auth info in next function */
_bt_obex_server_reject_authorize();
return FALSE;
}
-#endif
+
if (iter) {
const gchar *key;
GVariant *val;
g_variant_get(child, "(&s&s)", &elname, &elval);
memset(list_entry, 0, PBAP_VCARDLIST_MAXLENGTH);
-#if 0
- g_snprintf(list_entry, PBAP_VCARDLIST_MAXLENGTH - 1,
- "<card handle = \"%s\" name = \"%s\"/>", elname, elval);
-#else
+
g_snprintf(list_entry, PBAP_VCARDLIST_MAXLENGTH - 1,
"%s", elval);
-#endif
+
//If possible send as Array of <STRING, STRING>
BT_DBG("%s", list_entry);
vcard_list[i] = g_strdup(list_entry);
#define BLUETOOTH_PIN_CODE_MAX_LENGTH 16
-#ifdef TIZEN_GATT_CLIENT
#define BLUETOOTH_GATT_ATT_DATA_LENGTH_MAX 610 /**< GATT ATT value max len */
-#endif
/**
* This is Bluetooth Connected event role
BLUETOOTH_EVENT_GATT_READ_DESC, /**<Gatt Read Characteristic Descriptor Value */
BLUETOOTH_EVENT_GATT_WRITE_DESC, /**<Gatt Write Characteristic Descriptor Value */
BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED, /**<Gatt Char Descriptors Discovered Event*/
-#ifdef TIZEN_GATT_CLIENT
BLUETOOTH_EVENT_GATT_SERVER_CONNECTED,/**<Local Gatt Server connected event */
BLUETOOTH_EVENT_GATT_SERVER_DISCONNECTED, /**<Local Gatt Server Disconnected event */
BLUETOOTH_EVENT_GATT_CLIENT_CONNECTED,/**<Local Gatt Client connected event */
BLUETOOTH_EVENT_GATT_CLIENT_DISCONNECTED, /**<Local Gatt Client Disconnected event */
-#else
- BLUETOOTH_EVENT_GATT_CONNECTED,/**<Gatt connected event */
- BLUETOOTH_EVENT_GATT_DISCONNECTED, /**<Gatt Disconnected event */
-#endif
BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED, /**<Attribute protocol MTU changed event */
BLUETOOTH_EVENT_GATT_SERVER_ATT_MTU_CHANGED, /**<Attribute protocol Server MTU changed event */
BLUETOOTH_EVENT_GATT_SERVER_CHARACTERISTIC_VALUE_CHANGED, /**<Gatt Char write callback event */
typedef struct {
int count;
char **handle;
-#ifdef TIZEN_GATT_CLIENT
char uuids[BLUETOOTH_MAX_SERVICES_FOR_DEVICE][BLUETOOTH_UUID_STRING_MAX];
int inst_id[BLUETOOTH_MAX_SERVICES_FOR_DEVICE];
-#endif
} bt_gatt_handle_info_t;
-#ifdef TIZEN_GATT_CLIENT
/**
* Structure to a most basic GATT attribute handle data
*/
unsigned char uuid[16];
char address[BLUETOOTH_ADDRESS_STRING_LENGTH];
} bt_gatt_handle_property_t;
-#endif
/**
* Structure to GATT Remote service data
gboolean primary;
bt_gatt_handle_info_t include_handles;
bt_gatt_handle_info_t char_handle;
-#ifdef TIZEN_GATT_CLIENT
bt_gatt_handle_property_t prop; /* Added Service UUID, instance_id & associated remote device */
-#endif
} bt_gatt_service_property_t;
/**
unsigned int permission;
char *representation;
bt_gatt_handle_info_t char_desc_handle;
-#ifdef TIZEN_GATT_CLIENT
bt_gatt_handle_property_t prop; /* Added Char UUID, instance_id */
bt_gatt_handle_property_t svc_prop; /* Added Service UUID, instance_id */
char value[BLUETOOTH_GATT_ATT_DATA_LENGTH_MAX]; /* Added */
char address[BLUETOOTH_ADDRESS_STRING_LENGTH]; /* Added */
-#endif
} bt_gatt_char_property_t;
/**
char *uuid;
unsigned char *val;
unsigned int val_len;
-#ifdef TIZEN_GATT_CLIENT
bt_gatt_handle_property_t prop; /* Added Descriptor UUID, instance_id */
bt_gatt_handle_property_t char_prop; /* Added Char UUID, instance_id */
bt_gatt_handle_property_t svc_prop; /* Added Service UUID, instance_id */
char value[BLUETOOTH_GATT_ATT_DATA_LENGTH_MAX];/* Added */
char address[BLUETOOTH_ADDRESS_STRING_LENGTH]; /* Added */
-#endif
} bt_gatt_char_descriptor_property_t;
/**
bluetooth_device_address_t device_addr;
char *svc_path;
bluetooth_gatt_service_change_type_t change_type;
-#ifdef TIZEN_GATT_CLIENT
int inst_id;
char *uuid;
-#endif
} bt_gatt_service_change_t;
/**
*/
int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty);
-#ifdef TIZEN_GATT_CLIENT
int bluetooth_connect_le(const bluetooth_device_address_t *device_address,
gboolean auto_connect, int client_id);
-#else
-int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect);
-#endif
-#ifdef TIZEN_GATT_CLIENT
int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address,
int client_id);
-#else
-int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address);
-#endif
int bluetooth_get_gatt_data_batching_available_packets(
int *available_packets);
//#ifndef GATT_DIRECT
BT_GATT_SERVER_EVENT,
//#endif
-#ifdef TIZEN_GATT_CLIENT
BT_GATT_CLIENT_EVENT,
-#endif
BT_TDS_EVENT,
BT_OTP_EVENT,
BT_HDP_EVENT,
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
BT_AUDIO_AVC_EVENT,
-#endif
BT_MESH_EVENT,
/* Will be added */
} bt_event_type_t;
BT_HDP_GET_FD,
BT_GATT_GET_PRIMARY_SERVICES = BT_FUNC_GATT_BASE, /* GATT Client */
-#ifdef TIZEN_GATT_CLIENT
BT_GATT_CLIENT_REGISTER, /* GATT Client */
BT_GATT_CLIENT_UNREGISTER, /* GATT Client */
BT_GATT_GET_SERVICE_PROPERTIES, /* GATT Client */
BT_GATT_GET_CHARACTERISTIC_PROPERTIES, /* GATT Client */
BT_GATT_GET_INCLUDED_SERVICES, /* GATT Client */
-#endif
BT_GATT_DISCOVER_CHARACTERISTICS,
BT_GATT_SET_PROPERTY_REQUEST,
BT_GATT_READ_CHARACTERISTIC, /* GATT Client*/
-#ifdef TIZEN_GATT_CLIENT
BT_GATT_READ_DESCRIPTOR_VALUE, /* GATT Client */
BT_GATT_WRITE_CHARACTERISTIC_VALUE_BY_TYPE, /* GATT Client */
BT_GATT_WRITE_DESCRIPTOR_VALUE, /* GATT Client */
BT_GATT_WATCH_SERVICE_CHANGED_INDICATION, /* GATT Client */
BT_GATT_ACQUIRE_WRITE, /* GATT Client */
-#endif
BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR,
#ifndef GATT_NO_RELAY
BT_GATT_WATCH_CHARACTERISTIC,
/* Need to convert the design ID */
#define BT_STR_NOT_SUPPORT "Not support"
-#ifdef TIZEN_FEATURE_BT_DPM
#define BT_DPM_SYSPOPUP "dpm-syspopup"
-#endif
#define BT_FILE_VISIBLE_TIME "file/private/libug-setting-bluetooth-efl/visibility_time"
#define BT_GATT_SERVER_PATH "/org/projectx/bt/gatt_server"
#endif
-#ifdef TIZEN_GATT_CLIENT
#define BT_GATT_CLIENT_PATH "/org/projectx/bt/gatt_client"
-#endif
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
#define BT_AUDIO_AVC_PATH "/org/projectx/bt/avc_mode"
-#endif
#define BT_MESH_PATH "/org/projectx/bt/mesh"
#define BT_MEDIA_VOLUME_CHANGE "MediaVolumeStatus"
#define BT_NAME_OWNER_CHANGED "NameOwnerChanged"
-#ifdef TIZEN_GATT_CLIENT
#define BT_GATT_SERVER_CONNECTED "GattServerConnected"
#define BT_GATT_SERVER_DISCONNECTED "GattServerDisconnected"
#define BT_GATT_CLIENT_CONNECTED "GattClientConnected"
#define BT_GATT_CLIENT_DISCONNECTED "GattClientDisconnected"
-#else
-#define BT_GATT_CONNECTED "GattConnected"
-#define BT_GATT_DISCONNECTED "GattDisconnected"
-#endif
#ifndef GATT_DIRECT
#define BT_GATT_VALUE_CHANGED "GattValueChanged"
#define BT_GATT_SERVER_ACQUIRE_NOTIFICATION "GattServerAcquireNotify"
#endif
-#ifdef TIZEN_GATT_CLIENT
#define BT_GATT_CLIENT_READ_CHAR "GattReadCharValue"
#define BT_GATT_CLIENT_WRITE_CHAR "GattWriteCharValue"
#define BT_GATT_CLIENT_READ_DESC "GattReadDescriptor"
#define BT_GATT_CLIENT_WRITE_DESC "GattWriteDescriptor"
#define BT_GATT_CLIENT_SERVICE_CHANGED "GattServiceChanged"
-#endif
#define BT_GATT_REQ_ATT_MTU_CHANGED "GattReqAttMtuChanged"
#define BT_GATT_SERVER_ATT_MTU_CHANGED "GattServerAttMtuChanged"
#define BT_OTP_WRITE_CHAR_VAL "OtpWriteCharVal"
#define BT_OTP_INDICATION "OtpIndication"
#define BT_OTC_STATE_CHANGED "OtcStateChanged"
-
-#ifdef TIZEN_FEATURE_BT_AVC_TARGET
#define BT_AUDIO_AVC_MODE_CHANGED "AvcModeChanged"
-#endif
#define HEADED_PLUGIN_FILEPATH "/usr/lib/bt-plugin-headed.so"
#define HEADED_PLUGIN_FILEPATH64 "/usr/lib64/bt-plugin-headed.so"
int (*bt_get_mime_type)(char *file_name, char **mime_type);
};
-#ifdef TIZEN_FEATURE_BT_DPM
#define BT_DPM_SYSPOPUP "dpm-syspopup"
-#endif
-
-
#endif /* __BLUETOOTH_PLUGIN_H */
%define bt_permanent_log DISABLED
%define bt_http_proxy DISABLED
%define bt_factory_mode DISABLED
-%define bt_avc_target ENABLED
%define bt_vendor_operation DISABLED
BuildRequires: pkgconfig(aul)
export CFLAGS="$CFLAGS -DTIZEN_FEATURE_BT_IPSP"
export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE"
export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
-export CFLAGS="$CFLAGS -DTIZEN_GATT_CLIENT"
-export CFLAGS="$CFLAGS -DTIZEN_FEATURE_ACTD"
%define _servicefile packaging/bluetooth-frwk-common.service
%define _servicedir starter.target.wants
export CFLAGS="$CFLAGS -DTIZEN_FEATURE_BT_FACTORY_MODE"
%endif
-%if %{bt_avc_target} == ENABLED
-export CFLAGS="$CFLAGS -DTIZEN_FEATURE_BT_AVC_TARGET"
-%endif
-
%if %{bt_vendor_operation} == ENABLED
export CFLAGS="$CFLAGS -DTIZEN_FEATURE_BT_VENDOR_OPERATION"
%endif
-
-%ifarch %{ix86} x86_64
-export CFLAGS+=" -DTIZEN_TEST_EMUL"
-export CXXFLAGS+=" -DTIZEN_TEST_EMUL"
-export FFLAGS+=" -DTIZEN_TEST_EMUL"
-%endif
-
%if %{bt_bluez_hal} == ENABLED
export BT_INCLUDE_OAL_BLUEZ=ENABLED
export CFLAGS="$CFLAGS -DTIZEN_BT_INCLUDE_OAL_BLUEZ"
# extension-TM1
%ifarch %{ix86} || %{arm}
mkdir -p tm1
-export CFLAGS="$CFLAGS_DEFAULT -DTIZEN_FEATURE_RADIO -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
-export CXXFLAGS="$CXXFLAGS_DEFAULT -DTIZEN_FEATURE_RADIO -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
-export FFLAGS="$FFLAGS_DEFAULT -DTIZEN_FEATURE_RADIO -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
+export CFLAGS="$CFLAGS_DEFAULT -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
+export CXXFLAGS="$CXXFLAGS_DEFAULT -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
+export FFLAGS="$FFLAGS_DEFAULT -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
cmake . -DCMAKE_INSTALL_PREFIX=/usr \
-DCMAKE_LIB_DIR=%{_libdir} \
# extension-emulator
%ifarch %{ix86} x86_64
-export CFLAGS="${CFLAGS} -DTIZEN_TEST_EMUL -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
-export CXXFLAGS="${CXXFLAGS} -DTIZEN_TEST_EMUL -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
-export FFLAGS="${FFLAGS} -DTIZEN_TEST_EMUL -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
+export CFLAGS="${CFLAGS} -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
+export CXXFLAGS="${CXXFLAGS} -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
+export FFLAGS="${FFLAGS} -DTIZEN_FEATURE_BT_RFCOMM_DIRECT"
mkdir -p build_emulator
#define BT_MAX_EVENT_STR_LENGTH 50
#define BT_AGENT_SYSPOPUP_TIMEOUT_FOR_MULTIPLE_POPUPS 200
-#ifdef TIZEN_FEATURE_BT_DPM
int bt_launch_dpm_popup(char *mode)
{
int ret = 0;
return ret;
}
-#endif
static gboolean _bt_syspopup_timer_cb(gpointer user_data)
{
extern struct bluetooth_headed_plugin_t headed_plugin
__attribute__ ((visibility("default")));
struct bluetooth_headed_plugin_t headed_plugin = {
-#ifdef TIZEN_FEATURE_BT_DPM
bt_launch_dpm_popup,
-#else
- NULL,
-#endif
bt_launch_system_popup,
bt_destroy_popup_all,
bt_launch_unable_to_pairing_syspopup,
{"bluetooth_gatt_unregister_service", 99},
{"bluetooth_gatt_delete_services", 100},
-#if 0
- {"bluetooth_rfcomm_is_server_uuid_available" , 26},
-
- {"bluetooth_hdp_activate" , 30},
- {"bluetooth_hdp_deactivate" , 31},
- {"bluetooth_hdp_connect" , 32},
- {"bluetooth_hdp_disconnect" , 33},
- {"bluetooth_hdp_send_data" , 34},
-
- {"bluetooth_opc_init" , 35},
- {"bluetooth_opc_push_file" , 36},
- {"bluetooth_opc_cancel_push" , 37},
- {"bluetooth_opc_deinit" , 38},
- {"bluetooth_obex_server_init" , 39},
- {"bluetooth_obex_server_deinit" , 40},
- {"bluetooth_obex_server_accept_authorize" , 41},
- {"bluetooth_obex_server_reject_authorize" , 42},
- {"bluetooth_is_supported" , 43},
- {"bluetooth_opc_session_is_exist" , 46},
- {"bluetooth_obex_server_is_activated" , 47},
- {"bluetooth_obex_server_cancel_transfer" , 48},
-
- {"bluetooth_oob_read_local_data" , 50},
- {"bluetooth_oob_add_remote_data" , 51},
- {"bluetooth_oob_remove_remote_data" , 52},
-
- {"bluetooth_network_activate_server" , 60},
- {"bluetooth_network_deactivate_server" , 61},
- {"bluetooth_network_connect" , 62},
- {"bluetooth_network_disconnect" , 63},
-
- {"bluetooth_gatt_discover_primary_services", 64},
- {"bluetooth_gatt_discover_service_characteristics", 65},
- {"bluetooth_gatt_get_service_property", 66},
- {"bluetooth_gatt_get_characteristics_value", 67},
- {"bluetooth_gatt_set_characteristics_value", 68},
-#endif
/* -----------------------------------------*/
{"Finish" , 0x00ff},
{NULL , 0x0000},
};
-#if 0
-#define tc_result(success, tc_index) \
- TC_PRT("Test case [%d - %s] %s", tc_table[tc_index].tc_code, tc_table[tc_index].tc_name, ((success == TC_PASS) ? "Success" : "Failed"));
-#else
#define tc_result(success, tc_index)
-#endif
bluetooth_device_info_t bond_dev;
int is_bond_device = FALSE;
case 92:
{
+/*
#if TODO_40
ret = bluetooth_gatt_init();
if (ret < 0)
TC_PRT("gatt init failed with [0x%04x]", ret);
#endif
+*/
break;
}
case 93:
{
+/*
#if TODO_40
ret = bluetooth_gatt_deinit();
if (ret < 0)
TC_PRT("gatt deinit failed with [0x%04x]", ret);
#endif
+*/
break;
}
case 94:
{
+/*
#if TODO_40
char *service_uuid = g_strdup("00001802-0000-1000-8000-00805f9b34fb");
TC_PRT("service obj_path is %s", svc_obj_path);
#endif
+*/
break;
}
case 95:
{
-#if TODO_40
+/* #if TODO_40 */
/* testing with dummy values*/
+/*
char *char_uuid = g_strdup("00002a06-0000-1000-8000-00805f9b34fb");
bt_gatt_permission_t perms = 0;
bt_gatt_characteristic_property_t props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
TC_PRT("characteristic obj_path is %s", char_obj_path);
#endif
+*/
break;
}
case 96: {
+/*
#if TODO_40
char *desc_uuid = g_strdup("000026ff-0000-1000-8000-00805f9b34fb");
bt_gatt_permission_t perms = BLUETOOTH_GATT_PERMISSION_READ |
desc_uuid, perms, &desc_obj_path);
TC_PRT("add descriptor error is %d", ret);
#endif
+*/
break;
}
case 97: {
+/*
#if TODO_40
ret = bluetooth_gatt_register_service(svc_obj_path);
TC_PRT("register service error is %d", ret);
#endif
+*/
break;
}
case 98: {
+/*
#if TODO_40
ret = bluetooth_gatt_register_application();
TC_PRT("register service error is %d", ret);
#endif
+*/
break;
}
case 99: {
+/*
#if TODO_40
char char_data[4] = {10, 20, 30, 40};
int char_length = 4;
TC_PRT("update_characteristic error is %d", ret);
#endif
+*/
break;
}
case 100: {
+/*
#if TODO_40
ret = bluetooth_gatt_unregister_service(svc_obj_path);
TC_PRT("service removed with error is %d", ret);
#endif
+*/
break;
}
case 101:
+/*
#if TODO_40
ret = bluetooth_gatt_delete_services();
TC_PRT("services deleted with error is %d", ret);
#endif
+*/
break;
default:
{
// bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
// 2011.01.06
-#if 0
-// int i = 0;
- TC_PRT("BLUETOOTH_EVENT_BONDED_DEVICE_FOUND, result [0x%04x]", param->result);
- if (param->result >= BLUETOOTH_ERROR_NONE) {
- ///tc_result(TC_PASS, 15);
- bluetooth_device_info_t * bt_dev_info = (bluetooth_device_info_t*)param->param_data;
- TC_PRT("Dev Name = %s, Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X, COD (major,minor,service)= 0x%x:%x:%x\n", bt_dev_info->device_name.name,
- bt_dev_info->device_address.addr[0], bt_dev_info->device_address.addr[1], bt_dev_info->device_address.addr[2], \
- bt_dev_info->device_address.addr[3], bt_dev_info->device_address.addr[4], bt_dev_info->device_address.addr[5], \
- bt_dev_info->device_class.major_class, bt_dev_info->device_class.minor_class, bt_dev_info->device_class.service_class);
-
- } else if (param->result == BLUETOOTH_ERROR_END_OF_DEVICE_LIST) /*End of the Device found indication*/ {
- tc_result(TC_PASS, 15);
- TC_PRT("*****<<No more BLUETOOTH_EVENT_BONDED_DEVICE_FOUND indication>>***** ");
- } else {
- tc_result(TC_FAIL, 15);
- TC_PRT("*****API failed ***** ");
- }
-#endif
break;
}
{ TC_PRT("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
break;
}
-#if 0
- case BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED");
- bt_gatt_handle_info_t *prim_svc = param->param_data;
- int i;
-
- if (prim_svc == NULL) {
- TC_PRT("prim_svc is NULL");
- break;
- }
-
- for (i = 0; i < prim_svc->count; i++)
- TC_PRT("prim_svc[%d] = %s\n", i, prim_svc->handle[i]);
-
- break;
- }
-
- case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
- bt_gatt_discovered_char_t *svc_char = param->param_data;
- int i = 0;
-
- if (svc_char == NULL) {
- TC_PRT("svc_char is NULL");
- break;
- }
-
- if (svc_char->service_handle != NULL)
- TC_PRT("svc_char->service_handle %s \n", svc_char->service_handle);
-
- for (i = 0; i < svc_char->handle_info.count; i++)
- TC_PRT("svc_char.handle_info.handle[%d] = %s\n", i, svc_char->handle_info.handle[i]);
-
- break;
- }
-
- case BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED");
- bt_gatt_service_property_t *svc_pty = param->param_data;
- int i;
-
- if (svc_pty == NULL) {
- TC_PRT("char_pty is NULL \n");
- break;
- }
-
- if (svc_pty->service_handle != NULL)
- TC_PRT("svc_pty->service_handle %s \n", svc_pty->service_handle);
-
- if (svc_pty->uuid != NULL)
- TC_PRT("svc_pty->uuid %s \n", svc_pty->uuid);
-
- for (i = 0; i < svc_pty->handle_info.count; i++)
- TC_PRT("svc_char[%d] = %s\n", i, svc_pty->handle_info.handle[i]);
-
- break;
- }
-
- case BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED:
- {
- TC_PRT("BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED");
- bt_gatt_char_property_t *char_pty = param->param_data;
- int i = 0;
-
- if (char_pty->char_handle != NULL)
- TC_PRT("char_pty->char_handle %s \n", char_pty->char_handle);
-
- if (char_pty->uuid != NULL)
- TC_PRT("char_pty->uuid %s \n", char_pty->uuid);
-
- if (char_pty == NULL) {
- TC_PRT("char_pty is NULL \n");
- break;
- }
-
- if (char_pty->name != NULL)
- TC_PRT("char_pty->name %s \n", char_pty->name);
-
- if (char_pty->description != NULL)
- TC_PRT("char_pty->description %s \n", char_pty->description);
-
- if (char_pty->val != NULL) {
- TC_PRT("char_pty->val_len %d \n", char_pty->val_len);
-
- for (i = 0; i < char_pty->val_len; i++)
- TC_PRT("char_pty->val %02x \n", char_pty->val[i]);
- }
-
- break;
- }
-#endif
case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
{
bluetooth_authentication_request_info_t *auth_info = param->param_data;
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff