#include "bt-service-gatt.h"
#include "bt-service-util.h"
#include "bt-service-core-device.h"
+#include "bt-service-battery-monitor.h"
#include <oal-hardware.h>
#include <oal-manager.h>
typedef struct {
char *sender;
+ uid_t uid;
+ pid_t pid;
GSList *filter_list;
gboolean is_scanning;
} bt_adapter_le_scanner_t;
GSList *l;
GArray *out_param;
invocation_info_t *req_info = NULL;
- BT_DBG("+");
for (l = _bt_get_invocation_list(); l != NULL; ) {
req_info = l->data;
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)
/* 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));
}
}
-static int __get_advertisement_data(unsigned char *dest, unsigned char *src)
-{
- int length = 0;
- int i = 0;
-
- while (i <= 31) {
- int len = src[i];
-
- if ((len == 0) || (31 < (i + len))) {
- BT_INFO("length: %d", length);
- memcpy(dest, src, length);
- break;
- }
-
- length += (len + 1);
- i += (len + 1);
- }
-
- 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)
+ if (in_len <= 0)
return BLUETOOTH_ERROR_INTERNAL;
int i;
if (i > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1
|| i + len > in_len
- || i + len > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1) {
+ || i + len > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX) {
BT_ERR("Invalid advertising data");
return BLUETOOTH_ERROR_INTERNAL;
} else if (len == 0) {
int idx;
if (scanner->filter_list == NULL) {
- BT_INFO("This scanner is on Full Scan.");
+ BT_DBG("This scanner is on Full Scan.");
return TRUE;
}
name[data_len] = '\0';
g_free(data);
data = NULL;
- if (strncmp(filter_data->device_name,
- name, data_len) == 0) {
+ if (g_strrstr(name, filter_data->device_name) != NULL) {
BT_INFO("Device Name is matched in adv data.");
is_matched = TRUE;
}
name[data_len] = '\0';
g_free(data);
data = NULL;
- if (strncmp(filter_data->device_name,
- name, data_len) == 0) {
+ if (g_strrstr(name, filter_data->device_name) != NULL) {
BT_INFO("Device Name is matched in scan data.");
is_matched = TRUE;
}
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[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;
- }
+ adv_ind_len = scan_result->adv_data_len;
+ memcpy(adv_ind_data, scan_result->adv_data, BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX);
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;
- }
+ scan_resp_len = scan_result->scan_rsp_data_len;
+ memcpy(scan_resp_data, scan_result->scan_rsp_data, BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX);
- 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)
param = g_variant_new("(isnnn@ayn@ay)",
result, address,
- addr_type, scan_result->rssi,
+ scan_result->addr_type, scan_result->rssi,
adv_ind_len, adv_data_param,
scan_resp_len, scan_data_param);
_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_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;
}
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: {
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, params->tx_power_level, BT_ADV_DEFAULT_TIMEOUT);
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) {
return BLUETOOTH_ERROR_NONE;
}
-int _bt_start_le_scan(const char *sender)
+int _bt_start_le_scan(const char *sender, uid_t uid, pid_t pid)
{
bt_adapter_le_scanner_t *scanner;
int ret;
retv_if(scanner == NULL, BLUETOOTH_ERROR_INTERNAL);
scanner->sender = g_strdup(sender);
+ scanner->uid = uid;
+ scanner->pid = pid;
scanner_list = g_slist_append(scanner_list, scanner);
}
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;
} else {
BT_INFO("LE Full Scan is already on progress");
}
- goto done;
+ 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 */
return BLUETOOTH_ERROR_INTERNAL;
}
-done:
- scanner->is_scanning = TRUE;
return BLUETOOTH_ERROR_NONE;
}
/* 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 (!scanner)
return;
- if (scanner->is_scanning)
- _bt_stop_le_scan(sender);
+ _bt_bm_remove_scan_app(SCAN_LE, scanner->uid, scanner->pid);
+
+ if (scanner->is_scanning) {
+ /* Free 'scanner' into the function */
+ if (_bt_stop_le_scan(sender) != BLUETOOTH_ERROR_NOT_IN_OPERATION)
+ return;
+ }
scanner_list = g_slist_remove(scanner_list, scanner);
- g_free(scanner->sender);
- g_free(scanner);
+ __bt_free_le_scanner(scanner);
}
int _bt_service_le_init(void)
result = adapter_set_le_static_random_address(is_enable);
if (result != OAL_STATUS_SUCCESS) {
- BT_ERR("adapter_set_connectable failed: %d", result);
+ BT_ERR("adapter_set_le_static_random_address failed: %d", result);
result = BLUETOOTH_ERROR_INTERNAL;
} else {
BT_INFO("SetLeStaticRandomAddress as %d", is_enable);
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff