#define BT_ADV_DEFAULT_TIMEOUT 0
#define BT_ADV_DEFAULT_TX_POWER 4
#define BT_ADV_DEFAULT_CHANNEL_MAP 0
+#define BT_SCAN_INTERVAL_SPLIT 0.625
static const char BASE_UUID_CONVERTED[BT_UUID_128] = {
0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
};
typedef struct {
+ int adv_inst_max;
+ int rpa_offloading;
+ int max_filter;
+ int le_2m_phy;
+ int le_coded_phy;
+} bt_adapter_le_feature_info_t;
+
+/* Set Default values */
+static bt_adapter_le_feature_info_t le_feature_info = {1, 0, 0, 0, 0};
+
+typedef struct {
int adv_handle;
char *sender;
int data_len;
GSList *scanner_list = NULL;
static gboolean is_le_set_scan_parameter = FALSE;
static gboolean is_le_scanning = FALSE;
+static gboolean scan_filter_enabled = FALSE;
+
+static bluetooth_le_scan_params_t le_scan_params = { BT_LE_ACTIVE_SCAN, 0, 0 };
+
+static int g_gatt_client_id = 0;
+static void _bt_disable_all_scanner_status(void);
+
/******************************************* LE Scan *********************************************/
+static void __bt_free_le_scanner(bt_adapter_le_scanner_t *scanner)
+{
+ g_free(scanner->sender);
+ g_slist_free_full(scanner->filter_list, g_free);
+ g_free(scanner);
+}
+
+static void __bt_free_le_scanner_all(void)
+{
+ g_slist_free_full(scanner_list, (GDestroyNotify)__bt_free_le_scanner);
+ scanner_list = NULL;
+
+ is_le_scanning = FALSE;
+ is_le_set_scan_parameter = FALSE;
+ le_scan_params.type = BT_LE_ACTIVE_SCAN;
+ le_scan_params.interval = 0;
+ le_scan_params.window = 0;
+}
+
void _bt_adapter_set_le_status(bt_le_status_t status)
{
BT_INFO("adapter_le_state changed [%d] -> [%d]", adapter_le_state, status);
BT_INFO("+");
/* Get method invocation context */
- for (l = _bt_get_invocation_list(); l != NULL; l = g_slist_next(l)) {
+ for (l = _bt_get_invocation_list(); l != NULL; ) {
req_info = l->data;
+ l = g_slist_next(l);
if (req_info == NULL || req_info->service_function != service_function)
continue;
g_variant_new("(i)", result));
}
-
static void __bt_set_le_scan_status(gboolean mode)
{
+ BT_DBG("Set scanning status: %s", mode == TRUE ? "TRUE" : "FALSE");
is_le_scanning = mode;
}
GSList *l;
GArray *out_param;
invocation_info_t *req_info = NULL;
- BT_DBG("+");
- for (l = _bt_get_invocation_list(); l != NULL; l = g_slist_next(l)) {
+ for (l = _bt_get_invocation_list(); l != NULL; ) {
req_info = l->data;
+ l = g_slist_next(l);
if (req_info == NULL || req_info->service_function != service_function)
continue;
int *saved_handle;
bt_pending_adv_data_set_t *data;
- BT_DBG("Service function: [%d]", service_function);
ret_if(param == NULL);
saved_handle = (int*)req_info->user_data;
break;
}
default:
+ BT_DBG("Unknown function(%d)", service_function);
break;
}
}
- BT_DBG("-");
}
static void __bt_le_handle_server_instance_registered(event_gatts_register_t *data)
/* Get sender and adv handle for the server instance */
_bt_get_adv_handle_from_instance(data->server_inst, &adv_handle);
- if (adv_handle > 0) {
/* Check if pending Adv Data set or Scan response data set request is pending*/
for (l = adv_data_pending_list; l != NULL; l = l->next) {
info = l->data;
(void*)info, sizeof(bt_pending_adv_data_set_t));
}
goto data_free;
- }
}
}
}
/* Free data */
g_free(info->sender);
g_free(info);
+
+ BT_PERMANENT_LOG("Adv started %d", event->server_inst);
}
}
/* Free data */
g_free(info->sender);
g_free(info);
+
+ BT_PERMANENT_LOG("Adv stopped %d", event->server_inst);
}
}
if (sender == NULL) {
BT_ERR("Abnormal!!");
} else {
- BT_DBG("Sender [%s], adv handle [%d]", sender, adv_handle);
+ BT_INFO("Sender [%s], adv handle [%d]", sender, adv_handle);
if (event->status != OAL_STATUS_SUCCESS)
result = BLUETOOTH_ERROR_INTERNAL;
info = g_malloc0(sizeof(bt_pending_adv_data_set_t));
info->sender = sender;
info->adv_handle = adv_handle;
- BT_DBG("Sender [%s], adv handle [%d]", info->sender, info->adv_handle);
__bt_adapter_le_handle_pending_request_info(result,
BT_SET_SCAN_RESPONSE_DATA,
(void*)info, sizeof(bt_pending_adv_data_set_t));
int len = src[i];
if ((len == 0) || (31 < (i + len))) {
- BT_INFO("length: %d", length);
memcpy(dest, src, length);
break;
}
return length;
}
+static int __bt_get_ad_data_by_type(const char *in_data, int in_len,
+ char in_type, char **data, int *data_len)
+{
+ if (in_data == NULL || data == NULL || data_len == NULL)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ if (in_len <= 0)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ int i;
+ unsigned char len = 0;
+ int type = 0;
+
+ for (i = 0; i < in_len && i < BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1; i++) {
+ len = in_data[i];
+ if (len <= 0 || i + 1 >= in_len) {
+ BT_ERR("Invalid advertising data");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ type = in_data[i + 1];
+ if (type == in_type) {
+ i = i + 2;
+ len--;
+ break;
+ }
+
+ i += len;
+ len = 0;
+ }
+
+ if (i > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1
+ || i + len > in_len
+ || i + len > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX) {
+ BT_ERR("Invalid advertising data");
+ return BLUETOOTH_ERROR_INTERNAL;
+ } else if (len == 0) {
+ BT_DBG("AD Type 0x%02x data is not set", in_type);
+ *data = NULL;
+ *data_len = 0;
+ return BLUETOOTH_ERROR_NONE;
+ }
+
+ *data = g_memdup(&in_data[i], len);
+ if (*data == NULL)
+ return BLUETOOTH_ERROR_OUT_OF_MEMORY;
+ *data_len = len;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+static gboolean __bt_check_scan_result_uuid(const char *adv_data,
+ int adv_data_len, const char *svc_uuid, int uuid_len,
+ const char *uuid_mask, char ad_type)
+{
+ char *data = NULL;
+ int data_len = 0;
+ int i;
+
+ __bt_get_ad_data_by_type(adv_data, adv_data_len,
+ ad_type, &data, &data_len);
+ if (data != NULL) {
+ for (i = 0; i < data_len; i += uuid_len) {
+ if (uuid_len > (data_len - i))
+ break;
+
+ if (_bt_byte_arr_cmp_with_mask(data + i,
+ svc_uuid, uuid_mask, uuid_len) == 0) {
+ g_free(data);
+ return TRUE;
+ }
+ }
+ g_free(data);
+ }
+
+ return FALSE;
+}
+
+static gboolean __bt_check_scan_result_with_filter(const char *device_address,
+ const char *adv_data, int adv_data_len,
+ const char *scan_data, int scan_data_len,
+ const bt_adapter_le_scanner_t *scanner)
+{
+ GSList *l;
+ bluetooth_le_scan_filter_t *filter_data = NULL;
+ char *data = NULL;
+ int data_len = 0;
+ gboolean is_matched = FALSE;
+ int idx;
+
+ if (scanner->filter_list == NULL) {
+ BT_DBG("This scanner is on Full Scan.");
+ return TRUE;
+ }
+
+ for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
+ filter_data = l->data;
+
+ if (filter_data->added_features &
+ BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ _bt_convert_addr_type_to_string(address,
+ filter_data->device_address.addr);
+ if (strncmp(address, device_address,
+ BT_ADDRESS_STRING_SIZE) != 0)
+ continue;
+ }
+
+ /* Check service uuid filter */
+ if (filter_data->added_features &
+ BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
+ is_matched = FALSE;
+ const int ad_type_uuids[] = {
+ BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS,
+ BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS,
+ BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS,
+ BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS
+ };
+
+ for (idx = 0; idx < sizeof(ad_type_uuids) / sizeof(bt_le_ad_type_t); idx++) {
+ /* Check service uuid in advertising data */
+ if (__bt_check_scan_result_uuid(adv_data, adv_data_len,
+ (const char *)filter_data->service_uuid.data.data,
+ filter_data->service_uuid.data_len,
+ (const char *)filter_data->service_uuid_mask.data.data,
+ ad_type_uuids[idx]) == TRUE) {
+ BT_INFO("Service UUID is matched in adv data.");
+ is_matched = TRUE;
+ break;
+ }
+
+ /* Check service uuid in scan response data */
+ if (__bt_check_scan_result_uuid(scan_data, scan_data_len,
+ (const char *)filter_data->service_uuid.data.data,
+ filter_data->service_uuid.data_len,
+ (const char *)filter_data->service_uuid_mask.data.data,
+ ad_type_uuids[idx]) == TRUE) {
+ BT_INFO("Service UUID is matched in scan data.");
+ is_matched = TRUE;
+ break;
+ }
+ }
+
+ /* Service UUID is NOT matched. Continue to next filter */
+ if (is_matched == FALSE)
+ continue;
+ }
+
+ /* Check solicitation uuid filter */
+ if (filter_data->added_features &
+ BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
+ is_matched = FALSE;
+ const int ad_type_solicit_uuids[] = {
+ BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS,
+ BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS
+ };
+
+ for (idx = 0; idx < sizeof(ad_type_solicit_uuids) / sizeof(bt_le_ad_type_t); idx++) {
+ /* Check solicit uuid in advertising data */
+ if (__bt_check_scan_result_uuid(adv_data, adv_data_len,
+ (const char *)filter_data->service_solicitation_uuid.data.data,
+ filter_data->service_solicitation_uuid.data_len,
+ (const char *)filter_data->service_solicitation_uuid_mask.data.data,
+ ad_type_solicit_uuids[idx]) == TRUE) {
+ BT_INFO("Service Solicitation UUID is matched in adv data.");
+ is_matched = TRUE;
+ break;
+ }
+
+ /* Check solicit uuid in scan response data */
+ if (__bt_check_scan_result_uuid(scan_data, scan_data_len,
+ (const char *)filter_data->service_solicitation_uuid.data.data,
+ filter_data->service_solicitation_uuid.data_len,
+ (const char *)filter_data->service_solicitation_uuid_mask.data.data,
+ ad_type_solicit_uuids[idx]) == TRUE) {
+ BT_INFO("Service Solicitation UUID is matched in scan data.");
+ is_matched = TRUE;
+ break;
+ }
+ }
+
+ /* Service Solicitation UUID is NOT matched. Continue to next filter */
+ if (is_matched == FALSE)
+ continue;
+ }
+
+ /* Check device name filter */
+ if (filter_data->added_features &
+ BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
+ char name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX] = {0, };
+ data = NULL;
+ data_len = 0;
+ is_matched = FALSE;
+
+ /* Check device name in advertising data */
+ __bt_get_ad_data_by_type(adv_data, adv_data_len,
+ BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
+ &data, &data_len);
+ if (data != NULL) {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ memcpy(name, data, data_len);
+ name[data_len] = '\0';
+ g_free(data);
+ data = NULL;
+ if (g_strrstr(name, filter_data->device_name) != NULL) {
+ BT_INFO("Device Name is matched in adv data.");
+ is_matched = TRUE;
+ }
+ }
+
+ /* Check device name in scan response data */
+ __bt_get_ad_data_by_type(scan_data, scan_data_len,
+ BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
+ &data, &data_len);
+ if (data != NULL) {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ memcpy(name, data, data_len);
+ name[data_len] = '\0';
+ g_free(data);
+ data = NULL;
+ if (g_strrstr(name, filter_data->device_name) != NULL) {
+ BT_INFO("Device Name is matched in scan data.");
+ is_matched = TRUE;
+ }
+ }
+
+ /* Device Name is NOT matched. Continue to next filter */
+ if (is_matched == FALSE)
+ continue;
+ }
+
+ /* Check manufacturer data filter */
+ if (filter_data->added_features &
+ BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
+ data = NULL;
+ data_len = 0;
+ is_matched = FALSE;
+
+ /* Check manufacturer data in advertising data */
+ __bt_get_ad_data_by_type(adv_data, adv_data_len,
+ BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ &data, &data_len);
+ if (data != NULL) {
+ int manufacturer_id;
+ manufacturer_id = (data[1] << 8) + data[0];
+
+ if (filter_data->manufacturer_id == manufacturer_id) {
+ if (filter_data->manufacturer_data.data_len == 0) {
+ is_matched = TRUE;
+ } else {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ if (_bt_byte_arr_cmp_with_mask(data + 2,
+ (const char *)filter_data->manufacturer_data.data.data,
+ (const char *)filter_data->manufacturer_data_mask.data.data,
+ data_len - 2) == 0) {
+ BT_INFO("Manufacturer Data is matched in adv data.");
+ is_matched = TRUE;
+ }
+ }
+ }
+ g_free(data);
+ data = NULL;
+ }
+
+ /* Check manufacturer data in scan response data */
+ __bt_get_ad_data_by_type(scan_data, scan_data_len,
+ BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
+ &data, &data_len);
+ if (data != NULL) {
+ int manufacturer_id;
+ manufacturer_id = (data[1] << 8) + data[0];
+
+ if (filter_data->manufacturer_id == manufacturer_id) {
+ if (filter_data->manufacturer_data.data_len == 0) {
+ is_matched = TRUE;
+ } else {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ if (_bt_byte_arr_cmp_with_mask(data + 2,
+ (const char *)filter_data->manufacturer_data.data.data,
+ (const char *)filter_data->manufacturer_data_mask.data.data,
+ data_len - 2) == 0) {
+ BT_INFO("Manufacturer Data is matched in scan data.");
+ is_matched = TRUE;
+ }
+ }
+ }
+ g_free(data);
+ data = NULL;
+ }
+
+ /* Manufacturer Data is NOT matched. Continue to next filter */
+ if (is_matched == FALSE)
+ continue;
+ }
+
+ /* Check service data filter */
+ if (filter_data->added_features &
+ BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
+ data = NULL;
+ data_len = 0;
+ is_matched = FALSE;
+
+ /* Check service data in advertising data */
+ __bt_get_ad_data_by_type(adv_data,
+ adv_data_len,
+ BT_LE_AD_TYPE_SERVICE_DATA,
+ &data, &data_len);
+ if (data != NULL) {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ if (_bt_byte_arr_cmp_with_mask(data,
+ (const char *)filter_data->service_data.data.data,
+ (const char *)filter_data->service_data_mask.data.data,
+ data_len) == 0) {
+ BT_INFO("Service Data is matched in adv data.");
+ is_matched = TRUE;
+ }
+ g_free(data);
+ data = NULL;
+ }
+
+ /* Check service data in scan response data */
+ __bt_get_ad_data_by_type(scan_data,
+ scan_data_len,
+ BT_LE_AD_TYPE_SERVICE_DATA,
+ &data, &data_len);
+ if (data != NULL) {
+ if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
+ data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
+ if (_bt_byte_arr_cmp_with_mask(data,
+ (const char *)filter_data->service_data.data.data,
+ (const char *)filter_data->service_data_mask.data.data,
+ data_len) == 0) {
+ BT_INFO("Service Data is matched in scan data.");
+ is_matched = TRUE;
+ }
+ g_free(data);
+ data = NULL;
+ }
+
+ /* Service Data is NOT matched. Continue to next filter */
+ if (is_matched == FALSE)
+ continue;
+ }
+
+ BT_INFO("The scan result is conformable.");
+ return TRUE;
+ }
+
+ BT_INFO("The scan result is NOT conformable.");
+ return FALSE;
+}
+
static void __bt_le_handle_device_found(event_ble_scan_result_info *scan_result)
{
int result = BLUETOOTH_ERROR_NONE;
bt_adapter_le_scanner_t *scanner = NULL;
char address[BT_ADDRESS_STRING_SIZE];
int addr_type = 0x01; /* TODO: Need to get correct address type */
- unsigned char adv_ind_data[31];
- unsigned char scan_resp_data[31];
+ unsigned char adv_ind_data[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX];
+ unsigned char scan_resp_data[BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX];
int adv_ind_len = 0;
int scan_resp_len = 0;
- char *tmp_str = NULL;
GVariant *scan_data_param;
GVariant *adv_data_param;
GVariant *param;
GSList *l;
- BT_DBG("+");
ret_if(NULL == scan_result);
_bt_convert_addr_type_to_string(address, scan_result->address.addr);
memset(adv_ind_data, 0x00, sizeof(adv_ind_data));
adv_ind_len = __get_advertisement_data(
adv_ind_data, &(scan_result->adv_data[0]));
+ if (adv_ind_len > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX) {
+ BT_ERR("Invalid advertising data");
+ return;
+ }
memset(scan_resp_data, 0x00, sizeof(scan_resp_data));
scan_resp_len = __get_advertisement_data(
scan_resp_data, &(scan_result->adv_data[adv_ind_len]));
+ if (scan_resp_len > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX) {
+ BT_ERR("Invalid scan response data");
+ return;
+ }
- BT_INFO("Address: %s, RSSI: %d, adv_ind_len: %d, scan_resp_len: %d",
+ BT_DBG("Address: %s, RSSI: %d, adv_ind_len: %d, scan_resp_len: %d",
address, scan_result->rssi, adv_ind_len, scan_resp_len);
- tmp_str = _bt_service_convert_hex_to_string(scan_result->adv_data, 62);
- BT_INFO("Complete Data: [%s]", tmp_str);
- g_free(tmp_str);
- tmp_str = NULL;
-
- tmp_str = _bt_service_convert_hex_to_string(adv_ind_data, adv_ind_len);
- BT_INFO("Adv Ind Data: [%s]", tmp_str);
- g_free(tmp_str);
- tmp_str = NULL;
-
- tmp_str = _bt_service_convert_hex_to_string(scan_resp_data, scan_resp_len);
- BT_INFO("Scan resp Data: [%s]", tmp_str);
- g_free(tmp_str);
- tmp_str = NULL;
-
for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
scanner = l->data;
if (scanner->is_scanning == FALSE)
continue;
+ if (__bt_check_scan_result_with_filter(address, (const char *)adv_ind_data,
+ adv_ind_len, (const char *)scan_resp_data, scan_resp_len, scanner) == FALSE)
+ continue;
+
adv_data_param = g_variant_new_from_data((const GVariantType *)"ay",
adv_ind_data, adv_ind_len, TRUE, NULL, NULL);
scan_data_param = g_variant_new_from_data((const GVariantType *)"ay",
_bt_send_event_to_dest(scanner->sender, BT_LE_ADAPTER_EVENT,
BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, param);
}
-
- BT_DBG("-");
}
static void __bt_le_state_change_callback(int bt_status)
static void __bt_le_event_handler(int event_type, gpointer event_data)
{
- BT_INFO("OAL event = 0x%x, \n", event_type);
+ BT_INFO("OAL event = %d", event_type);
switch (event_type) {
case OAL_EVENT_BLE_ENABLED: {
}
case OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED: {
BT_INFO("OAL Event: Server Instance Registered");
- event_gatts_register_t* event = g_memdup(event_data, sizeof(event_gatts_register_t));
- /* GATT Server Registered event is handled in MAIN thread context */
- __bt_le_handle_server_instance_registered(event);
+ __bt_le_handle_server_instance_registered((event_gatts_register_t *)event_data);
break;
}
case OAL_EVENT_BLE_ADVERTISING_STARTED: {
}
case OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE: {
BT_INFO("OAL Event: Advertising Enabled");
- event_ble_multiadv_status* event = (event_ble_multiadv_status*)g_memdup(event_data,
- sizeof(event_ble_multiadv_status));
- __bt_le_multi_advertising_enabled(event);
+ __bt_le_multi_advertising_enabled((event_ble_multiadv_status *)event_data);
break;
}
case OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE: {
BT_INFO("OAL Event: Advertising Disabled");
- event_ble_multiadv_status* event = (event_ble_multiadv_status*)g_memdup(event_data,
- sizeof(event_ble_multiadv_status));
- __bt_le_multi_advertising_disabled(event);
+ __bt_le_multi_advertising_disabled((event_ble_multiadv_status *)event_data);
break;
}
case OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA: {
BT_INFO("OAL Event: Advertising Data set successfully");
- event_ble_multiadv_status* event = (event_ble_multiadv_status*)g_memdup(event_data,
- sizeof(event_ble_multiadv_status));
- __bt_le_multi_advertising_set_data(event);
+ __bt_le_multi_advertising_set_data((event_ble_multiadv_status *)event_data);
break;
}
case OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE: {
}
case OAL_EVENT_BLE_DISCOVERY_STARTED: {
__bt_set_le_scan_status(TRUE);
-
__bt_adapter_le_handle_pending_request_info(
BLUETOOTH_ERROR_NONE,
BT_START_LE_DISCOVERY, NULL, 0);
}
__bt_set_le_scan_status(FALSE);
+ _bt_disable_all_scanner_status();
__bt_adapter_le_handle_pending_request_info(
BLUETOOTH_ERROR_NONE,
BT_STOP_LE_DISCOVERY, NULL, 0);
}
case OAL_EVENT_BLE_REMOTE_DEVICE_FOUND: {
event_ble_scan_result_info *scan_result = event_data;
- BT_INFO("OAL Event: OAL_EVENT_BLE_REMOTE_DEVICE_FOUND");
__bt_le_handle_device_found(scan_result);
break;
}
+ case OAL_EVENT_GATTC_REGISTRATION: {
+ event_gattc_register_t *gattc_event = event_data;
+ char uuid_str[BLUETOOTH_UUID_STRING_MAX];
+ char *default_uuid_string;
+
+ default_uuid_string = _bt_gatt_get_default_gatt_client_uuid();
+ _bt_uuid_to_string((service_uuid_t*)&(gattc_event->client_uuid), uuid_str);
+ BT_INFO("default UUID [%s] current registered uuid [%s]",
+ default_uuid_string, uuid_str);
+ if (g_strcmp0(uuid_str, default_uuid_string)) {
+ BT_INFO("This is not the default GATT client that is registered");
+
+ g_free(default_uuid_string);
+ break;
+ }
+ BT_INFO("GATT CLient instance registered is default client: ID [%d]",
+ gattc_event->client_if);
+ g_free(default_uuid_string);
+
+ g_gatt_client_id = gattc_event->client_if;
+ break;
+ }
+ case OAL_EVENT_BLE_LOCAL_FEATURES: {
+ event_adapter_le_features_t *le_features = event_data;
+
+ le_feature_info.le_2m_phy = le_features->le_2m_phy_support;
+ le_feature_info.le_coded_phy = le_features->le_coded_phy_support;
+ le_feature_info.max_filter = le_features->max_adv_filter;
+
+ BT_INFO("Adapter LE 2M PHY Support [%s]", le_feature_info.le_2m_phy ? "TRUE" : "FALSE");
+ BT_INFO("Adapter LE CODED PHY Support [%s]", le_feature_info.le_coded_phy ? "TRUE" : "FALSE");
+
+ break;
+ }
default:
break;
}
int _bt_le_init(void)
{
- BT_DBG("+");
/* Register LE event handler */
_bt_service_register_event_handler_callback(BT_ADAPTER_LE_MODULE, __bt_le_event_handler);
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
void _bt_le_deinit(void)
{
- BT_DBG("+");
/* Un-register LE event handler */
_bt_service_unregister_event_handler_callback(BT_ADAPTER_LE_MODULE);
- BT_DBG("-");
}
static void __bt_le_update_discovery_status(bt_adapter_discovery_state_t status)
static int __bt_le_state_handle_request(gboolean enable)
{
int result = BLUETOOTH_ERROR_NONE;
- BT_DBG("");
switch (_bt_adapter_get_le_status()) {
case BT_LE_ACTIVATING: {
break;
}
default:
- BT_ERR("Unknown state: %d", _bt_adapter_get_le_status);
+ BT_ERR("Unknown state: %d", _bt_adapter_get_le_status());
break;
}
int server_instance;
bt_pending_adv_data_set_t *info = NULL;
int result = OAL_STATUS_SUCCESS;
- BT_DBG("+");
if (__bt_is_factory_test_mode()) {
BT_ERR("Unable to start advertising in factory binary !!");
}
if (enable) {
+ /* Set the Advertising filter policy Parameter in HAL */
+ result = adapter_ble_set_filter_policy(params->filter_policy);
+
+ if (result != OAL_STATUS_SUCCESS){
+ BT_ERR("OAL API adapter_ble_set_filter_policy Fail %d", result);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
/* Set Advertising parameters to Stack */
result = adapter_ble_multi_adv_update(server_instance, params->interval_min, params->interval_max,
- params->type, BT_ADV_DEFAULT_CHANNEL_MAP, BT_ADV_DEFAULT_TX_POWER, BT_ADV_DEFAULT_TIMEOUT);
+ params->type, BT_ADV_DEFAULT_CHANNEL_MAP, params->tx_power_level, BT_ADV_DEFAULT_TIMEOUT);
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("OAL API adapter_ble_multi_adv_update Fail %d", result);
return BLUETOOTH_ERROR_INTERNAL;
}
_bt_get_previous_adv_data(adv, length, server_instance);
- BT_DBG("ADV Data length [%d] Server Instance [%d] Adv handle [%d]", length, server_instance, adv_handle);
+ BT_DBG("ADV Data length [%d] Server Instance [%d] Adv handle [%d]", *length, server_instance, adv_handle);
return BLUETOOTH_ERROR_NONE;
}
}
_bt_get_previous_scan_rsp_data(response, length, server_instance);
- BT_DBG("SCAN RSP Data length [%d] Server Instance [%d] Adv handle [%d]", length, server_instance, adv_handle);
+ BT_DBG("SCAN RSP Data length [%d] Server Instance [%d] Adv handle [%d]", *length, server_instance, adv_handle);
return BLUETOOTH_ERROR_NONE;
}
unsigned char *ptr;
int num_uuids;
- BT_INFO("+");
retv_if(NULL == adv_data, BLUETOOTH_ERROR_INVALID_PARAM);
retv_if(NULL == adv_setup, BLUETOOTH_ERROR_INVALID_PARAM);
int len = ptr[0];
int type = ptr[1];
- BT_INFO("len: %d, type: %x", len, type);
+ BT_DBG("len: %d, type: 0x%x", len, type);
switch (type) {
case 0xFF: /* Manufacturer Data */
break;
case 0x14: { /* 16 bit Solicit UUID */
int c;
- int k;
num_uuids = (len -1)/2;
adv_setup->solicit_uuid = g_malloc0(sizeof(char) * 16 * num_uuids);
char *tmp = adv_setup->solicit_uuid;
if (c < num_uuids)
tmp += 16;
}
- /* DEBUG: Test*/
- for (k = 0; k < 16 * num_uuids; k++)
- BT_DBG("%x", adv_setup->solicit_uuid[k]);
break;
}
case 0x02: { /* 16 bit Service UUID */
int c;
- int k;
num_uuids = (len -1)/2;
adv_setup->service_uuid = g_malloc0(sizeof(char) * 16 * num_uuids);
char *tmp = adv_setup->service_uuid;
if (c < num_uuids)
tmp += 16;
}
- /* DEBUG: Test*/
- for (k = 0; k < 16 * num_uuids; k++)
- BT_DBG("%x", adv_setup->service_uuid[k]);
break;
}
case 0x16: { /* Service Data */
ptr += len + 1;
}
- BT_INFO("-");
return BLUETOOTH_ERROR_NONE;
}
/* Set Server instance[Product Requirement] */
adv_setup.tx_power = 4;
- BT_DBG("####Service UUID len [%d], service data len [%d] Solicit UUID len [%d]",
+ BT_DBG("Service UUID len [%d], service data len [%d] Solicit UUID len [%d]",
adv_setup.solicit_uuid_len, adv_setup.service_uuid_len, adv_setup.service_data_len);
result = adapter_ble_multi_adv_set_inst_data(server_instance, &adv_setup);
if (result != OAL_STATUS_SUCCESS) {
BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
param);
}
+
+ g_free(old_mdata);
}
/* Time to update new ADV data completely in Table */
BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
param);
}
+
+ g_free(old_mdata);
}
/* Time to update new Scan Response data completely in Table */
return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
}
+ BT_DBG("inteval %f, win %f, type %d", params->interval, params->window, params->type);
+
if (params->interval < BT_LE_SCAN_INTERVAL_MIN ||
params->interval > BT_LE_SCAN_INTERVAL_MAX)
return BLUETOOTH_ERROR_INVALID_PARAM;
if (params->window > params->interval)
return BLUETOOTH_ERROR_INVALID_PARAM;
- itv = params->interval / BT_ADV_INTERVAL_SPLIT;
- win = params->window / BT_ADV_INTERVAL_SPLIT;
+ itv = params->interval / BT_SCAN_INTERVAL_SPLIT;
+ win = params->window / BT_SCAN_INTERVAL_SPLIT;
ret = gattc_set_le_scan_param(params->type, itv, win);
if (OAL_STATUS_SUCCESS != ret) {
}
is_le_set_scan_parameter = TRUE;
- BT_INFO("Set scan parameters");
+
+ BT_INFO("Set scan parameters inteval %f, win %f, type %d",
+ itv * BT_SCAN_INTERVAL_SPLIT, win * BT_SCAN_INTERVAL_SPLIT, params->type);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_prepare_scan_parameters(bluetooth_le_scan_params_t *params, int scan_type)
+{
+ if (_bt_adapter_get_status() != BT_ACTIVATED &&
+ _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ if (params)
+ BT_DBG("inteval %f, win %f", params->interval, params->window);
+ else
+ BT_DBG("type %d", scan_type);
+
+ if (params) {
+ if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (params->window < BT_LE_SCAN_WINDOW_MIN || params->window > BT_LE_SCAN_WINDOW_MAX)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (params->window > params->interval)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ le_scan_params.interval = params->interval;
+ le_scan_params.window = params->window;
+ } else {
+ le_scan_params.type = scan_type;
+ if (le_scan_params.interval == 0) {
+ /* Set default scan interval same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
+ le_scan_params.interval = 5120;
+ le_scan_params.window = 512;
+ }
+ }
+
+ is_le_set_scan_parameter = TRUE;
return BLUETOOTH_ERROR_NONE;
}
gboolean __send_le_scan_reply(gpointer data)
{
- int value = (int)data;
+ int value = (intptr_t)data;
if (0 == value) {
BT_DBG("Send reply to BT_STOP_LE_DISCOVERY");
return FALSE;
}
+static int __bt_get_available_scan_filter_slot_id(void)
+{
+ GSList *l;
+ bt_adapter_le_scanner_t *scanner;
+ GSList *fl;
+ bluetooth_le_scan_filter_t *filter_data;
+ gboolean *slot_check_list = NULL;
+ int i;
+
+ if (le_feature_info.max_filter == 0) {
+ BT_ERR("Scan filter is NOT Supported");
+ return -1;
+ }
+ slot_check_list = g_malloc0(sizeof(gboolean) * le_feature_info.max_filter);
+
+ for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
+ scanner = l->data;
+ for (fl = scanner->filter_list; fl != NULL; fl = g_slist_next(fl)) {
+ filter_data = fl->data;
+ if (filter_data->slot_id < le_feature_info.max_filter)
+ slot_check_list[filter_data->slot_id] = TRUE;
+ }
+ }
+
+ for (i = 0; i < le_feature_info.max_filter; i++) {
+ if (slot_check_list[i] == FALSE) {
+ g_free(slot_check_list);
+ return i;
+ }
+ }
+
+ BT_ERR("There is NO available slot for scan filter.");
+ g_free(slot_check_list);
+ return -1;
+}
+
+int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ bt_adapter_le_scanner_t *scanner = NULL;
+ bluetooth_le_scan_filter_t *scan_filter_data = NULL;
+ int slot_id;
+
+ slot_id = __bt_get_available_scan_filter_slot_id();
+ if (slot_id == -1)
+ return BLUETOOTH_ERROR_NO_RESOURCES;
+
+ oal_ble_scan_filter_t filter_data = {.slot_id = slot_id, .device_address = (bt_address_t*)&filter->device_address, .device_name = filter->device_name,
+ .service_uuid = (oal_uuid_t*)&filter->service_uuid.data, .service_uuid_len = filter->service_uuid.data_len,
+ .service_uuid_mask = (oal_uuid_t*)&filter->service_uuid_mask.data, .service_uuid_mask_len = filter->service_uuid_mask.data_len,
+ .service_solicitation_uuid = (oal_uuid_t*)&filter->service_solicitation_uuid.data,
+ .service_solicitation_uuid_len = filter->service_solicitation_uuid.data_len,
+ .service_solicitation_uuid_mask = (oal_uuid_t*)&filter->service_solicitation_uuid_mask.data,
+ .service_solicitation_uuid_mask_len = filter->service_solicitation_uuid_mask.data_len,
+ .service_data = filter->service_data.data.data, .service_data_len = filter->service_data.data_len,
+ .service_data_mask = filter->service_data_mask.data.data, .service_data_mask_len = filter->service_data_mask.data_len,
+ .manufacturer_id = filter->manufacturer_id, .manufacturer_data = filter->manufacturer_data.data.data,
+ .manufacturer_data_len = filter->manufacturer_data.data_len, .manufacturer_data_mask = filter->manufacturer_data_mask.data.data,
+ .manufacturer_data_mask_len = filter->manufacturer_data_mask.data_len , .added_features = filter->added_features
+ };
+ ret = gattc_register_scan_filter(&filter_data);
+
+ if (OAL_STATUS_SUCCESS != ret) {
+ BT_ERR("gattc_register_scan_filter failed");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ scanner = __bt_find_scanner_from_list(sender);
+
+ if (scanner == NULL) {
+ scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
+
+ if (scanner == NULL)
+ return BLUETOOTH_ERROR_MEMORY_ALLOCATION;
+
+ scanner->sender = g_strdup(sender);
+ scanner_list = g_slist_append(scanner_list, scanner);
+ }
+
+ scan_filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
+
+ memcpy(scan_filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
+
+ scan_filter_data->slot_id = slot_id;
+ scanner->filter_list = g_slist_append(scanner->filter_list, scan_filter_data);
+
+ return ret;
+}
+
+int _bt_unregister_all_scan_filters(const char* sender)
+{
+ int ret;
+ bt_adapter_le_scanner_t *scanner = NULL;
+ bluetooth_le_scan_filter_t *filter_data = NULL;
+ GSList *l;
+
+ scanner = __bt_find_scanner_from_list(sender);
+
+ if (scanner == NULL) {
+ BT_ERR("There is NO available scanner.");
+ return BLUETOOTH_ERROR_NOT_FOUND;
+ }
+ for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
+ filter_data = l->data;
+
+ ret = gattc_unregister_scan_filter(filter_data->slot_id);
+
+ if (OAL_STATUS_SUCCESS != ret)
+ BT_ERR("gattc_unregister_scan_filter failed for slot_id = [%d]", filter_data->slot_id);
+ }
+
+ g_slist_free_full(scanner->filter_list, g_free);
+ scanner->filter_list = NULL;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
int _bt_start_le_scan(const char *sender)
{
bt_adapter_le_scanner_t *scanner;
scanner_list = g_slist_append(scanner_list, scanner);
}
+ /* Check scanning is in progress or not */
if (scanner->is_scanning) {
BT_ERR("BT is already in LE scanning");
return BLUETOOTH_ERROR_IN_PROGRESS;
}
+ scanner->is_scanning = TRUE;
+
+ /* Check scanning is in progress or not by other users */
if (_bt_is_le_scanning()) {
int value = 1;
-
BT_INFO("LE Full Scan is already on progress");
- g_idle_add(__send_le_scan_reply, (void *)value);
- goto done;
- }
-
- if (is_le_set_scan_parameter == FALSE) {
- bluetooth_le_scan_params_t scan_params;
-
- /* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
- scan_params.type = 0x01;
- scan_params.interval = 5000;
- scan_params.window = 500;
- _bt_set_scan_parameters(&scan_params);
+ g_idle_add(__send_le_scan_reply, (void *)(intptr_t)value);
+
+ /* Disable scan filter if filter is NULL */
+ if (scan_filter_enabled == TRUE) {
+ if (scanner->filter_list == NULL) {
+ BT_INFO("Disable LE Scan Filter");
+ ret = gattc_disable_scan_filter(0);
+ if (ret != OAL_STATUS_SUCCESS)
+ BT_ERR("gattc_disable_scan_filter failed");
+ scan_filter_enabled = FALSE;
+ } else {
+ BT_INFO("LE Filter Scan is continue");
+ }
+ } else {
+ BT_INFO("LE Full Scan is already on progress");
+ }
+ return BLUETOOTH_ERROR_NONE;
+ } else {
+ if (is_le_set_scan_parameter == FALSE) {
+ /* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
+ bluetooth_le_scan_params_t scan_params;
+ scan_params.type = BT_LE_ACTIVE_SCAN;
+ scan_params.interval = 5120;
+ scan_params.window = 512;
+ _bt_set_scan_parameters(&scan_params);
+ } else
+ _bt_set_scan_parameters(&le_scan_params);
+
+ /* Enable scan filter if filter is exisiting */
+ if (scanner->filter_list == NULL) {
+ scan_filter_enabled = FALSE;
+ } else {
+ BT_INFO("Enable LE Scan Filter");
+ ret = gattc_enable_scan_filter(0);
+ if (ret != OAL_STATUS_SUCCESS)
+ BT_ERR("gattc_enable_scan_filter failed");
+ scan_filter_enabled = TRUE;
+ }
}
BT_INFO("Start LE Full Scan");
- ret = gattc_start_le_discovery();
+ ret = gattc_start_le_discovery(g_gatt_client_id);
+
if (OAL_STATUS_SUCCESS != ret) {
BT_ERR("gattc_start_le_discovery failed");
return BLUETOOTH_ERROR_INTERNAL;
}
-done:
- scanner->is_scanning = TRUE;
return BLUETOOTH_ERROR_NONE;
}
int _bt_stop_le_scan(const char *sender)
{
+ int result = BLUETOOTH_ERROR_NONE;
bt_adapter_le_scanner_t *scanner;
gboolean next_scanning = FALSE;
GSList *l;
int ret;
+ /* Check scanning is in progress or not */
scanner = __bt_find_scanner_from_list(sender);
- if (scanner == NULL || scanner->is_scanning == FALSE)
+ if (scanner == NULL)
+ return BLUETOOTH_ERROR_NOT_IN_OPERATION;
+
+ if (scanner->is_scanning == FALSE)
return BLUETOOTH_ERROR_NOT_IN_OPERATION;
scanner->is_scanning = FALSE;
for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
- scanner = l->data;
- if (scanner->is_scanning == TRUE)
+ bt_adapter_le_scanner_t *scanner_iter = l->data;
+
+ if (scanner_iter->is_scanning == TRUE)
next_scanning = TRUE;
}
if (next_scanning == TRUE) {
int value = 0;
- g_idle_add(__send_le_scan_reply, (void *)value);
- return BLUETOOTH_ERROR_NONE;
+ g_idle_add(__send_le_scan_reply, (void *)(intptr_t)value);
+ result = BLUETOOTH_ERROR_NONE;
} else {
BT_INFO("Just stop LE scan");
- }
+ ret = gattc_stop_le_discovery(g_gatt_client_id);
- ret = gattc_stop_le_discovery();
- if (OAL_STATUS_SUCCESS != ret) {
- BT_ERR("gattc_start_le_discovery failed");
- return BLUETOOTH_ERROR_INTERNAL;
+ if (OAL_STATUS_SUCCESS != ret) {
+ BT_ERR("gattc_start_le_discovery failed");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+
+// TODO: Disable scan filter
+ is_le_set_scan_parameter = FALSE;
+
+ le_scan_params.type = BT_LE_ACTIVE_SCAN;
+ le_scan_params.interval = 0;
+ le_scan_params.window = 0;
}
- is_le_set_scan_parameter = FALSE;
- return BLUETOOTH_ERROR_NONE;
+ _bt_unregister_all_scan_filters(sender);
+
+ scanner_list = g_slist_remove(scanner_list, scanner);
+ __bt_free_le_scanner(scanner);
+
+ return result;
+}
+
+static void _bt_disable_all_scanner_status(void)
+{
+ GSList *l;
+ bt_adapter_le_scanner_t *scanner;
+
+ for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
+ scanner = l->data;
+ scanner->is_scanning = FALSE;
+ }
}
void _bt_check_le_scanner_app_termination(const char *sender)
void _bt_service_le_deinit(void)
{
le_deinit();
+ __bt_free_le_scanner_all();
}
+int _bt_is_advertising(void)
+{
+ int ret = is_advertising();
+
+ if (ret == BLUETOOTH_ERROR_NONE)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+gboolean _bt_is_le_2m_phy_supported(void)
+{
+ if (le_feature_info.le_2m_phy)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+gboolean _bt_is_le_coded_phy_supported(void)
+{
+ if (le_feature_info.le_coded_phy)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+gboolean _bt_is_scan_filter_supported(void)
+{
+ if (le_feature_info.max_filter > 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+int _bt_set_le_privacy(gboolean set_privacy)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+
+ if (__bt_is_factory_test_mode()) {
+ BT_ERR("Unable to set le privacy in factory binary !!");
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (_bt_adapter_get_status() != BT_ACTIVATED &&
+ _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ result = adapter_ble_set_privacy(set_privacy);
+ if (result != OAL_STATUS_SUCCESS) {
+ BT_ERR("adapter_set_le_privacy failed: %d", result);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return result;
+}
+
+
+int _bt_set_white_list(bluetooth_device_address_t *device_address, int address_type, bool is_add)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ if (__bt_is_factory_test_mode()) {
+ if(is_add)
+ BT_ERR("Unable to add to white list in factory binary !!");
+ else
+ BT_ERR("Unable to remove white list in factory binary !!");
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ if(_bt_adapter_get_status() != BT_ACTIVATED ){
+ BT_ERR("Bluetooth adapter is disabled");
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ result = adapter_set_white_list((bt_address_t*)device_address, address_type, is_add);
+ if (result != OAL_STATUS_SUCCESS) {
+ if(is_add)
+ BT_ERR("Add to White List Failed %d", result);
+ else
+ BT_ERR("Remove from white list Failed %d", result);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return result;
+}
+
+int _bt_set_manufacturer_data(bluetooth_manufacturer_data_t *m_data)
+{
+ GVariant *manufac_data, *param = NULL;
+ int result = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(m_data, return);
+
+ if (_bt_adapter_get_status() != BT_ACTIVATED &&
+ _bt_adapter_get_le_status() != BT_LE_ACTIVATED)
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+
+ result = adapter_set_manufacturer_data((oal_manufacturer_data_t*)m_data);
+ if (result != OAL_STATUS_SUCCESS) {
+ BT_ERR("Set manufacturer data Failed %d", result);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+ /*data has been successfully sent to the stack, inititate manufacturer data change event */
+ manufac_data = g_variant_new_from_data((const GVariantType *)"ay",
+ m_data->data, m_data->data_len, TRUE, NULL, NULL);
+ param = g_variant_new("(@ay)", manufac_data);
+ _bt_send_event(BT_ADAPTER_EVENT,
+ BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
+ param);
+
+ return result;
+}
/*************************************** LE Scan APIs *********************************************/
+
+int _bt_set_le_static_random_address(gboolean is_enable)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+
+ if (__bt_is_factory_test_mode()) {
+ BT_ERR("Unable to set le random address in factory binary !!");
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (_bt_adapter_get_status() != BT_ACTIVATED &&
+ _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ result = adapter_set_le_static_random_address(is_enable);
+ if (result != OAL_STATUS_SUCCESS) {
+ BT_ERR("adapter_set_connectable failed: %d", result);
+ result = BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ BT_INFO("SetLeStaticRandomAddress as %d", is_enable);
+ result = BLUETOOTH_ERROR_NONE;
+ }
+
+ return result;
+}