4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
7 * Girishashok Joshi <girish.joshi@samsung.com>
8 * Chanyeol Park <chanyeol.park@samsung.com>
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing, software
17 * distributed under the License is distributed on an "AS IS" BASIS,
18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 * See the License for the specific language governing permissions and
20 * limitations under the License.
25 //#include <dbus/dbus-glib.h>
26 //#include <dbus/dbus.h>
32 #if !defined(LIBNOTIFY_SUPPORT) && !defined(LIBNOTIFICATION_SUPPORT)
33 #include <syspopup_caller.h>
36 #ifdef ENABLE_TIZEN_2_4
37 #include <journal/device.h>
40 #include "bt-internal-types.h"
41 #include "bt-service-common.h"
42 #include "bt-service-event.h"
43 #include "bt-service-adapter.h"
44 #include "bt-service-adapter-le.h"
47 #define BT_ADV_INTERVAL_MIN 20 /* msec */
48 #define BT_ADV_INTERVAL_MAX 10240
49 #define BT_ADV_INTERVAL_SPLIT 0.625
50 #define BT_DEFAULT_ADV_MIN_INTERVAL 500
51 #define BT_DEFAULT_ADV_MAX_INTERVAL 500
52 #define BT_ADV_FILTER_POLICY_DEFAULT 0x00
53 #define BT_ADV_TYPE_DEFAULT 0x00
54 #define BT_ADV_FILTER_POLICY_ALLOW_SCAN_CONN_WL_ONLY 0x03
60 } bt_adapter_le_feature_info_t;
65 gboolean is_advertising;
66 } bt_adapter_le_adv_slot_t;
72 } bt_adapter_le_scanner_t;
74 static bluetooth_advertising_params_t adv_params = {
75 BT_DEFAULT_ADV_MIN_INTERVAL,
76 BT_DEFAULT_ADV_MAX_INTERVAL,
77 BT_ADV_FILTER_POLICY_DEFAULT,
79 static bluetooth_advertising_data_t adv_data = { {0} };
80 static int adv_data_len;
81 static bluetooth_scan_resp_data_t resp_data = { {0} };
82 static int resp_data_len;
84 static bt_adapter_le_feature_info_t le_feature_info = { 1, 0, 0 };
85 static bt_adapter_le_adv_slot_t *le_adv_slot = NULL;
87 GSList *scanner_list = NULL;
88 static gboolean is_le_set_scan_parameter = FALSE;
89 static gboolean is_le_scanning = FALSE;
90 static gboolean scan_filter_enabled = FALSE;
91 static bt_le_scan_type_t le_scan_type = BT_LE_PASSIVE_SCAN;
93 void __bt_free_le_adv_slot(void)
97 if (le_adv_slot == NULL)
100 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
101 if (le_adv_slot[i].sender)
102 g_free(le_adv_slot[i].sender);
108 int _bt_service_adapter_le_init(void)
110 le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
112 return BLUETOOTH_ERROR_NONE;
115 void _bt_service_adapter_le_deinit(void)
117 __bt_free_le_adv_slot();
120 gboolean _bt_update_le_feature_support(const char *item, const char *value)
122 if (item== NULL || value == NULL)
125 if (g_strcmp0(item, "adv_inst_max") == 0) {
126 if (atoi(value) != le_feature_info.adv_inst_max) {
127 __bt_free_le_adv_slot();
128 le_feature_info.adv_inst_max = atoi(value);
129 le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
131 } else if (g_strcmp0(item, "rpa_offloading") == 0) {
132 le_feature_info.rpa_offloading = atoi(value);
133 } else if (g_strcmp0(item, "max_filter") == 0) {
134 le_feature_info.max_filter = atoi(value);
136 BT_DBG("No registered item");
143 static gboolean __bt_is_factory_test_mode(void)
146 #ifdef ENABLE_TIZEN_2_4
147 if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
148 BT_ERR("Get the DUT Mode fail");
153 BT_INFO("DUT Test Mode !!");
160 int __bt_get_available_adv_slot_id(const char *sender, int adv_handle, gboolean use_reserved_slot)
164 if (le_adv_slot == NULL)
167 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
168 if (le_adv_slot[i].sender == NULL)
170 if ((g_strcmp0(le_adv_slot[i].sender, sender) == 0) && (le_adv_slot[i].adv_handle == adv_handle))
174 if (le_feature_info.adv_inst_max <= 2)
176 else if (le_feature_info.adv_inst_max > 2 && use_reserved_slot == TRUE)
181 for (; i < le_feature_info.adv_inst_max; i++) {
182 if (le_adv_slot[i].sender == NULL)
189 void __bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id)
191 if (le_adv_slot[slot_id].sender == NULL) {
192 le_adv_slot[slot_id].sender = strdup(sender);
193 le_adv_slot[slot_id].adv_handle = adv_handle;
197 void __bt_unregister_adv_slot_owner(int slot_id)
199 g_free(le_adv_slot[slot_id].sender);
200 le_adv_slot[slot_id].sender = NULL;
201 le_adv_slot[slot_id].adv_handle = 0;
204 const char* _bt_get_adv_slot_owner(int slot_id)
206 if (le_adv_slot == NULL)
209 return le_adv_slot[slot_id].sender;
212 int _bt_get_adv_slot_adv_handle(int slot_id)
214 if (le_adv_slot == NULL)
217 return le_adv_slot[slot_id].adv_handle;
220 void _bt_set_advertising_status(int slot_id, gboolean mode)
222 le_adv_slot[slot_id].is_advertising = mode;
225 gboolean _bt_is_advertising(void)
227 gboolean status = FALSE;
230 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
231 if (le_adv_slot[i].is_advertising == TRUE)
238 void _bt_stop_advertising_by_terminated_process(const char* terminated_name)
242 if (le_adv_slot == NULL)
245 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
246 if (le_adv_slot[i].sender != NULL) {
247 if (strcasecmp(terminated_name, le_adv_slot[i].sender) == 0) {
248 BT_ERR("Stop advertising by terminated process(%s).", terminated_name);
249 _bt_set_advertising(terminated_name, le_adv_slot[i].adv_handle, FALSE, FALSE);
255 gboolean _bt_get_advertising_params(bluetooth_advertising_params_t *params)
260 memcpy(params, &adv_params, sizeof(bluetooth_advertising_params_t));
265 int _bt_set_advertising(const char *sender, int adv_handle, gboolean enable, gboolean use_reserved_slot)
268 GError *error = NULL;
272 if (__bt_is_factory_test_mode()) {
273 BT_ERR("Unable to start advertising in factory binary !!");
274 return BLUETOOTH_ERROR_NOT_SUPPORT;
277 if (_bt_adapter_get_status() != BT_ACTIVATED &&
278 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
279 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
282 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
284 BT_ERR("There is NO available slot!!");
285 return BLUETOOTH_ERROR_NO_RESOURCES;
288 if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
289 return BLUETOOTH_ERROR_IN_PROGRESS;
291 if (le_adv_slot[slot_id].sender != NULL && le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
292 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
294 proxy = _bt_get_adapter_proxy();
295 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
297 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
298 g_variant_new("(bi)", enable, slot_id),
299 G_DBUS_CALL_FLAGS_NONE,
305 BT_ERR("SetAdvertising Fail: %s", error->message);
306 g_clear_error(&error);
307 return BLUETOOTH_ERROR_INTERNAL;
311 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
313 le_adv_slot[slot_id].is_advertising = enable;
314 BT_INFO("Set advertising [%d]", enable);
317 g_variant_unref(ret);
319 return BLUETOOTH_ERROR_NONE;
322 int _bt_set_custom_advertising(const char *sender, int adv_handle,
323 gboolean enable, bluetooth_advertising_params_t *params, gboolean use_reserved_slot)
327 GError *error = NULL;
332 BT_CHECK_PARAMETER(params, return);
334 if (__bt_is_factory_test_mode()) {
335 BT_ERR("Unable to start advertising in factory binary !!");
336 return BLUETOOTH_ERROR_NOT_SUPPORT;
339 if (_bt_adapter_get_status() != BT_ACTIVATED &&
340 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
341 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
344 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
346 BT_ERR("There is NO available slot!!");
347 return BLUETOOTH_ERROR_NO_RESOURCES;
350 if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
351 return BLUETOOTH_ERROR_IN_PROGRESS;
353 if (le_adv_slot[slot_id].sender != NULL && le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
354 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
356 proxy = _bt_get_adapter_proxy();
357 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
359 if (params->interval_min > params->interval_max ||
360 params->interval_min < BT_ADV_INTERVAL_MIN ||
361 params->interval_max > BT_ADV_INTERVAL_MAX)
362 return BLUETOOTH_ERROR_INVALID_PARAM;
364 if (params->filter_policy > BLUETOOTH_ALLOW_SCAN_CONN_WHITE_LIST)
365 return BLUETOOTH_ERROR_INVALID_PARAM;
367 if (params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_HIGH ||
368 params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_LOW ||
369 params->type == BLUETOOTH_ADV_NON_CONNECTABLE)
370 return BLUETOOTH_ERROR_NOT_SUPPORT;
372 min = params->interval_min / BT_ADV_INTERVAL_SPLIT;
373 max = params->interval_max / BT_ADV_INTERVAL_SPLIT;
375 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingParameters",
376 g_variant_new("(uuuui)", min, max,
377 params->filter_policy, params->type,
378 slot_id), G_DBUS_CALL_FLAGS_NONE,
382 BT_ERR("SetAdvertisingParameters Fail: %s", error->message);
383 g_clear_error(&error);
384 return BLUETOOTH_ERROR_INTERNAL;
387 adv_params.interval_min = params->interval_min;
388 adv_params.interval_max = params->interval_max;
389 adv_params.filter_policy = params->filter_policy;
390 adv_params.type= params->type;
393 g_variant_unref(ret);
395 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
396 g_variant_new("(bi)", enable, slot_id),
397 G_DBUS_CALL_FLAGS_NONE,
403 BT_ERR("SetAdvertising Fail: %s", error->message);
404 g_clear_error(&error);
405 return BLUETOOTH_ERROR_INTERNAL;
409 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
411 __bt_unregister_adv_slot_owner(slot_id);
413 le_adv_slot[slot_id].is_advertising = enable;
414 BT_INFO_C("Set advertising [%d]", enable);
416 g_variant_unref(ret);
418 return BLUETOOTH_ERROR_NONE;
421 static int __bt_get_ad_data_by_type(char *in_data, int in_len,
422 char in_type, char **data, int *data_len)
424 if (in_data == NULL || data == NULL || data_len == NULL)
425 return BLUETOOTH_ERROR_INTERNAL;
428 return BLUETOOTH_ERROR_INTERNAL;
434 for (i = 0; i < in_len; i++) {
436 if (len <= 0 || i + 1 >= in_len) {
437 BT_ERR("Invalid advertising data");
438 return BLUETOOTH_ERROR_INTERNAL;
441 type = in_data[i + 1];
442 if (type == in_type) {
452 if (i + len > in_len) {
453 BT_ERR("Invalid advertising data");
454 return BLUETOOTH_ERROR_INTERNAL;
455 } else if (len == 0) {
456 BT_DBG("AD Type 0x%02x data is not set", in_type);
459 return BLUETOOTH_ERROR_NONE;
462 *data = g_memdup(&in_data[i], len);
464 return BLUETOOTH_ERROR_OUT_OF_MEMORY;
467 return BLUETOOTH_ERROR_NONE;
470 int _bt_get_advertising_data(bluetooth_advertising_data_t *adv, int *length)
472 BT_CHECK_PARAMETER(adv, return);
473 BT_CHECK_PARAMETER(length, return);
475 memcpy(adv, &adv_data, sizeof(adv_data));
476 *length = adv_data_len;
478 return BLUETOOTH_ERROR_NONE;
481 int _bt_set_advertising_data(const char *sender, int adv_handle,
482 bluetooth_advertising_data_t *adv, int length, gboolean use_reserved_slot)
485 GError *error = NULL;
486 GVariant *ret, *ad_data, *param = NULL;
487 GVariant *temp = NULL;
488 GVariantBuilder *builder;
490 char *old_mdata = NULL;
491 char *new_mdata = NULL;
496 if (__bt_is_factory_test_mode()) {
497 BT_ERR("Unable to set advertising data in factory binary !!");
498 return BLUETOOTH_ERROR_NOT_SUPPORT;
501 BT_CHECK_PARAMETER(adv, return);
503 if (_bt_adapter_get_status() != BT_ACTIVATED &&
504 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
505 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
508 proxy = _bt_get_adapter_proxy();
509 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
511 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
513 BT_ERR("There is NO available slot!!");
514 return BLUETOOTH_ERROR_NO_RESOURCES;
517 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
518 for (i = 0; i < length; i++) {
519 g_variant_builder_add(builder, "y", adv->data[i]);
522 temp = g_variant_new("ay", builder);
523 g_variant_builder_unref(builder);
524 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingData",
525 g_variant_new("(@ayi)", temp, slot_id),
526 G_DBUS_CALL_FLAGS_NONE,
530 BT_ERR("SetAdvertisingData Fail: %s", error->message);
531 g_clear_error(&error);
532 return BLUETOOTH_ERROR_INTERNAL;
535 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
537 __bt_get_ad_data_by_type((char *)adv_data.data, adv_data_len, 0xff,
538 &old_mdata, &old_len);
539 __bt_get_ad_data_by_type((char *)adv->data, length, 0xff,
540 &new_mdata, &new_len);
541 if (old_len != new_len ||
542 (old_mdata && new_mdata &&
543 memcmp(old_mdata, new_mdata, new_len))) {
544 ad_data = g_variant_new_from_data((const GVariantType *)"ay",
545 new_mdata, new_len, TRUE, NULL, NULL);
546 param = g_variant_new("(@ay)", ad_data);
547 _bt_send_event(BT_ADAPTER_EVENT,
548 BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
554 memset(&adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
555 memcpy(&adv_data, adv, length);
556 adv_data_len = length;
558 BT_INFO("Set advertising data");
560 g_variant_unref(ret);
562 return BLUETOOTH_ERROR_NONE;
565 int _bt_get_scan_response_data(bluetooth_scan_resp_data_t *response, int *length)
567 BT_CHECK_PARAMETER(response, return);
568 BT_CHECK_PARAMETER(length, return);
570 memcpy(response, &resp_data, sizeof(resp_data));
571 *length = resp_data_len;
573 return BLUETOOTH_ERROR_NONE;
576 int _bt_set_scan_response_data(const char *sender, int adv_handle,
577 bluetooth_scan_resp_data_t *response, int length, gboolean use_reserved_slot)
580 GError *error = NULL;
581 GVariant *ret, *scan_data, *param = NULL;
582 GVariant *temp = NULL;
583 GVariantBuilder *builder;
585 char *old_mdata = NULL;
586 char *new_mdata = NULL;
591 if (__bt_is_factory_test_mode()) {
592 BT_ERR("Unable to set scan response list in factory binary !!");
593 return BLUETOOTH_ERROR_NOT_SUPPORT;
596 BT_CHECK_PARAMETER(response, return);
598 if (_bt_adapter_get_status() != BT_ACTIVATED &&
599 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
600 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
603 proxy = _bt_get_adapter_proxy();
604 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
606 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
608 BT_ERR("There is NO available slot!!");
609 return BLUETOOTH_ERROR_NO_RESOURCES;
611 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
612 for (i = 0; i < length; i++) {
613 g_variant_builder_add(builder, "y", response->data[i]);
616 temp = g_variant_new("ay", builder);
617 g_variant_builder_unref(builder);
618 ret = g_dbus_proxy_call_sync(proxy, "SetScanRespData",
619 g_variant_new("(@ayi)", temp, slot_id),
620 G_DBUS_CALL_FLAGS_NONE,
624 BT_ERR("SetScanRespData Fail: %s", error->message);
625 g_clear_error(&error);
626 return BLUETOOTH_ERROR_INTERNAL;
629 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
631 /* Compare with previous scan resp data */
632 __bt_get_ad_data_by_type((char *)resp_data.data, resp_data_len, 0xff,
633 &old_mdata, &old_len);
634 __bt_get_ad_data_by_type((char *)response->data, length, 0xff,
635 &new_mdata, &new_len);
636 if (old_len != new_len ||
637 (old_mdata && new_mdata &&
638 memcmp(old_mdata, new_mdata, new_len))) {
639 scan_data = g_variant_new_from_data((const GVariantType *)"ay",
640 new_mdata, new_len, TRUE, NULL, NULL);
641 param = g_variant_new("(@ay)", scan_data);
642 _bt_send_event(BT_ADAPTER_EVENT,
643 BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
649 memset(&resp_data, 0x00, sizeof(bluetooth_scan_resp_data_t));
650 memcpy(&resp_data, response, length);
651 resp_data_len = length;
654 g_variant_unref(ret);
655 BT_INFO("Set scan response data");
656 return BLUETOOTH_ERROR_NONE;
659 int _bt_set_scan_parameters(bluetooth_le_scan_params_t *params)
662 GError *error = NULL;
667 BT_CHECK_PARAMETER(params, return);
669 if (_bt_adapter_get_status() != BT_ACTIVATED &&
670 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
671 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
674 proxy = _bt_get_adapter_proxy();
675 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
677 if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
678 return BLUETOOTH_ERROR_INVALID_PARAM;
680 if (params->window < BT_LE_SCAN_WINDOW_MIN || params->window > BT_LE_SCAN_WINDOW_MAX)
681 return BLUETOOTH_ERROR_INVALID_PARAM;
683 if (params->window > params->interval)
684 return BLUETOOTH_ERROR_INVALID_PARAM;
686 itv = params->interval / BT_ADV_INTERVAL_SPLIT;
687 win = params->window / BT_ADV_INTERVAL_SPLIT;
689 ret = g_dbus_proxy_call_sync(proxy, "SetScanParameters",
690 g_variant_new("(uuu)", params->type, itv, win),
691 G_DBUS_CALL_FLAGS_NONE, -1,
695 BT_ERR("SetScanParameters Fail: %s", error->message);
696 g_clear_error(&error);
697 return BLUETOOTH_ERROR_INTERNAL;
700 _bt_set_le_scan_type(params->type);
702 is_le_set_scan_parameter = TRUE;
705 g_variant_unref(ret);
706 BT_INFO("Set scan parameters");
707 return BLUETOOTH_ERROR_NONE;
710 bt_adapter_le_scanner_t* __bt_find_scanner_from_list(const char *sender)
713 bt_adapter_le_scanner_t *scanner;
715 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
717 if (g_strcmp0(scanner->sender, sender) == 0)
724 int __bt_get_available_scan_filter_slot_id(void)
727 bt_adapter_le_scanner_t *scanner;
729 bluetooth_le_scan_filter_t *filter_data;
730 gboolean *slot_check_list;
733 if (le_feature_info.max_filter == 0) {
734 BT_ERR("Scan filter is NOT Supported");
737 slot_check_list = g_malloc0(sizeof(gboolean) * le_feature_info.max_filter);
739 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
741 for (fl = scanner->filter_list; fl != NULL; fl = g_slist_next(fl)) {
742 filter_data = fl->data;
743 if (filter_data->slot_id < le_feature_info.max_filter) {
744 slot_check_list[filter_data->slot_id] = TRUE;
749 for (i = 0; i < le_feature_info.max_filter; i++) {
750 if (slot_check_list[i] == FALSE) {
751 g_free(slot_check_list);
756 BT_ERR("There is NO available slot for scan filter.");
757 g_free(slot_check_list);
761 int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id)
764 GError *error = NULL;
765 GVariant *ret, *param;
766 GVariant *arr_uuid_param, *arr_uuid_mask_param;
767 GVariant *arr_data_param, *arr_data_mask_param;
769 GArray *arr_uuid_mask;
771 GArray *arr_data_mask;
772 bt_adapter_le_scanner_t *scanner = NULL;
773 bluetooth_le_scan_filter_t *filter_data = NULL;
774 int feature_selection = 0;
776 *slot_id = __bt_get_available_scan_filter_slot_id();
778 return BLUETOOTH_ERROR_NO_RESOURCES;
780 proxy = _bt_get_adapter_proxy();
781 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
783 arr_uuid = g_array_new(TRUE, TRUE, sizeof(guint8));
784 arr_uuid_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
785 arr_data = g_array_new(TRUE, TRUE, sizeof(guint8));
786 arr_data_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
788 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
789 arr_uuid, filter->service_uuid.data_len * sizeof(guint8), TRUE, NULL, NULL);
790 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
791 arr_uuid_mask, filter->service_uuid_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
792 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
793 arr_data, filter->service_data.data_len * sizeof(guint8), TRUE, NULL, NULL);
794 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
795 arr_data_mask, filter->service_data_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
797 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
798 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
799 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
801 _bt_convert_addr_type_to_string(address, filter->device_address.addr);
803 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
805 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
806 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS, // filter_type
807 slot_id, // filter_index
809 0, // company_id_mask
810 arr_uuid_param, // p_uuid
811 arr_uuid_mask_param, // p_uuid_mask
814 arr_data_param, // p_data
815 arr_data_mask_param); // p_mask
817 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
818 param, G_DBUS_CALL_FLAGS_NONE,
822 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
823 g_clear_error(&error);
826 g_variant_unref(ret);
829 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
830 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME;
832 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
834 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
835 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME, // filter_type
836 slot_id, // filter_index
838 0, // company_id_mask
839 arr_uuid_param, // p_uuid
840 arr_uuid_mask_param, // p_uuid_mask
841 filter->device_name, // string
843 arr_data_param, // p_data
844 arr_data_mask_param);
846 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
847 param, G_DBUS_CALL_FLAGS_NONE,
851 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
852 g_clear_error(&error);
855 g_variant_unref(ret);
858 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
859 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID;
861 g_array_append_vals(arr_uuid, filter->service_uuid.data.data, filter->service_uuid.data_len * sizeof(guint8));
862 g_array_append_vals(arr_uuid_mask, filter->service_uuid_mask.data.data, filter->service_uuid_mask.data_len * sizeof(guint8));
864 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
865 arr_uuid, filter->service_uuid.data_len * sizeof(guint8), TRUE, NULL, NULL);
866 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
867 arr_uuid, filter->service_uuid_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
869 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
871 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
872 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID, // filter_type
873 slot_id, // filter_index
875 0, // company_id_mask
876 arr_uuid_param, // p_uuid
877 arr_uuid_mask_param, // p_uuid_mask
880 arr_data_param, // p_data
881 arr_data_mask_param);
883 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
884 param, G_DBUS_CALL_FLAGS_NONE,
888 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
889 g_clear_error(&error);
892 g_variant_unref(ret);
895 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
896 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
898 g_array_append_vals(arr_uuid, filter->service_solicitation_uuid.data.data, filter->service_solicitation_uuid.data_len * sizeof(guint8));
899 g_array_append_vals(arr_uuid_mask, filter->service_solicitation_uuid_mask.data.data, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8));
901 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
902 arr_uuid, filter->service_solicitation_uuid.data_len * sizeof(guint8), TRUE, NULL, NULL);
903 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
904 arr_uuid, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
906 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
908 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
909 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID, // filter_type
910 slot_id, // filter_index
912 0, // company_id_mask
913 arr_uuid_param, // p_uuid
914 arr_uuid_mask_param, // p_uuid_mask
917 arr_data_param, // p_data
918 arr_data_mask_param);
920 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
921 G_DBUS_CALL_FLAGS_NONE,
925 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
926 g_clear_error(&error);
929 g_variant_unref(ret);
932 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
933 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
935 g_array_append_vals(arr_data, filter->service_data.data.data, filter->service_data.data_len * sizeof(guint8));
936 g_array_append_vals(arr_data_mask, filter->service_data_mask.data.data, filter->service_data_mask.data_len * sizeof(guint8));
938 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
939 arr_uuid, filter->service_data.data_len * sizeof(guint8), TRUE, NULL, NULL);
940 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
941 arr_uuid, filter->service_data_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
943 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
945 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
946 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA, // filter_type
947 slot_id, // filter_index
949 0, // company_id_mask
950 arr_uuid_param, // p_uuid
951 arr_uuid_mask_param, // p_uuid_mask
954 arr_data_param, // p_data
955 arr_data_mask_param);
957 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
958 G_DBUS_CALL_FLAGS_NONE,
962 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
963 g_clear_error(&error);
966 g_variant_unref(ret);
969 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
970 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
972 g_array_append_vals(arr_data, filter->manufacturer_data.data.data, filter->manufacturer_data.data_len * sizeof(guint8));
973 g_array_append_vals(arr_data_mask, filter->manufacturer_data_mask.data.data, filter->manufacturer_data_mask.data_len * sizeof(guint8));
975 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
976 arr_uuid, filter->manufacturer_data.data_len * sizeof(guint8), TRUE, NULL, NULL);
977 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
978 arr_uuid, filter->manufacturer_data_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
980 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
982 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
983 BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA, // filter_type
984 slot_id, // filter_index
985 filter->manufacturer_id, // company_id
986 0xFFFF, // company_id_mask
987 arr_uuid_param, // p_uuid
988 arr_uuid_mask_param, // p_uuid_mask
991 arr_data_param, // p_data
992 arr_data_mask_param);
994 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
995 G_DBUS_CALL_FLAGS_NONE,
999 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1000 g_clear_error(&error);
1003 g_variant_unref(ret);
1006 g_array_free(arr_uuid, TRUE);
1007 g_array_free(arr_uuid_mask, TRUE);
1008 g_array_free(arr_data, TRUE);
1009 g_array_free(arr_data_mask, TRUE);
1011 BT_DBG("Filter selection %.2x", feature_selection);
1013 param = g_variant_new("(iiiiiiiiiiii)",
1015 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1016 slot_id, // filter_index
1017 feature_selection, // feat_seln
1018 0, // list_logic_type (OR - 0x00, AND - 0x01)
1019 1, // filt_logic_type (OR - 0x00, AND - 0x01)
1020 -127, // rssi_high_thres
1021 -127, // rssi_low_thres
1022 0, // dely_mode (Immediate - 0x00, on found - 0x01, batched - 0x02)
1025 0); // found_timeout_cnt
1026 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_param_setup",
1027 param, G_DBUS_CALL_FLAGS_NONE,
1031 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1032 g_clear_error(&error);
1035 scanner = __bt_find_scanner_from_list(sender);
1036 if (scanner == NULL) {
1037 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1038 scanner->sender = strdup(sender);
1039 scanner_list = g_slist_append(scanner_list, scanner);
1042 filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
1043 memcpy(filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
1044 filter_data->slot_id = *slot_id;
1046 scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
1049 g_variant_unref(ret);
1050 return BLUETOOTH_ERROR_NONE;
1053 int _bt_unregister_scan_filter(const char *sender, int slot_id)
1056 GError *error = NULL;
1058 bt_adapter_le_scanner_t *scanner = NULL;
1059 bluetooth_le_scan_filter_t *filter_data = NULL;
1061 gboolean is_slot_id_found = FALSE;
1063 scanner = __bt_find_scanner_from_list(sender);
1064 if (scanner == NULL) {
1065 BT_ERR("There is NO available scanner.");
1066 return BLUETOOTH_ERROR_NOT_FOUND;
1069 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1070 filter_data = l->data;
1071 if (filter_data->slot_id == slot_id) {
1072 is_slot_id_found = TRUE;
1076 if (is_slot_id_found == FALSE) {
1077 BT_ERR("There is NO registered slot.");
1078 return BLUETOOTH_ERROR_NOT_FOUND;
1081 proxy = _bt_get_adapter_proxy();
1082 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1084 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1085 g_variant_new("(ii)", 0, slot_id),
1086 G_DBUS_CALL_FLAGS_NONE,
1090 BT_ERR("scan_filter_clear Fail: %s", error->message);
1091 g_clear_error(&error);
1094 scanner->filter_list = g_slist_remove(scanner->filter_list, filter_data);
1095 g_free(filter_data);
1098 g_variant_unref(ret);
1099 return BLUETOOTH_ERROR_NONE;
1102 int _bt_unregister_all_scan_filters(const char *sender)
1105 GError *error = NULL;
1107 bt_adapter_le_scanner_t *scanner = NULL;
1108 bluetooth_le_scan_filter_t *filter_data = NULL;
1111 scanner = __bt_find_scanner_from_list(sender);
1112 if (scanner == NULL) {
1113 BT_ERR("There is NO available scanner.");
1114 return BLUETOOTH_ERROR_NOT_FOUND;
1117 proxy = _bt_get_adapter_proxy();
1118 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1120 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1121 filter_data = l->data;
1123 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1124 g_variant_new("(ii)", 0, filter_data->slot_id),
1125 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1128 BT_ERR("scan_filter_clear Fail: %s", error->message);
1129 g_clear_error(&error);
1132 g_variant_unref(ret);
1135 g_slist_free_full(scanner->filter_list, g_free);
1136 scanner->filter_list = NULL;
1138 return BLUETOOTH_ERROR_NONE;
1141 int _bt_start_le_scan(const char *sender)
1144 GError *error = NULL;
1146 bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1148 if (scanner == NULL) {
1149 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1150 scanner->sender = strdup(sender);
1151 scanner_list = g_slist_append(scanner_list, scanner);
1154 if (scanner->is_scanning == TRUE) {
1155 BT_ERR("BT is already in LE scanning");
1156 return BLUETOOTH_ERROR_IN_PROGRESS;
1159 proxy = _bt_get_adapter_proxy();
1160 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1162 if (_bt_is_le_scanning()) {
1163 if (scan_filter_enabled == TRUE) {
1164 if (scanner->filter_list == NULL) {
1165 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1166 g_variant_new("(ib)", 0, FALSE),
1167 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1170 BT_ERR("scan_filter_clear Fail: %s", error->message);
1171 g_clear_error(&error);
1175 g_variant_unref(ret);
1176 BT_INFO("Disable LE Scan Filter");
1177 scan_filter_enabled = FALSE;
1179 BT_INFO("LE Filter Scan is continue");
1182 BT_INFO("LE Full Scan is already on progress");
1185 scanner->is_scanning = TRUE;
1186 return BLUETOOTH_ERROR_NONE;
1188 if (is_le_set_scan_parameter == FALSE) {
1189 /* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
1190 bluetooth_le_scan_params_t scan_params;
1191 scan_params.type = 1;
1192 scan_params.interval = 5000;
1193 scan_params.window = 500;
1194 _bt_set_scan_parameters(&scan_params);
1197 if (scanner->filter_list == NULL) {
1198 BT_INFO("Start LE Full Scan");
1199 scan_filter_enabled = FALSE;
1201 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1202 g_variant_new("(ib)", 0, TRUE),
1203 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1206 BT_ERR("scan_filter_clear Fail: %s", error->message);
1207 g_clear_error(&error);
1211 g_variant_unref(ret);
1212 BT_INFO("Enable LE Scan Filter");
1213 scan_filter_enabled = TRUE;
1217 ret = g_dbus_proxy_call_sync(proxy, "StartLEDiscovery",
1218 NULL,G_DBUS_CALL_FLAGS_NONE,
1222 BT_ERR("StartLEDiscovery Fail: %s", error->message);
1223 g_clear_error(&error);
1224 return BLUETOOTH_ERROR_INTERNAL;
1228 g_variant_unref(ret);
1230 scanner->is_scanning = TRUE;
1231 return BLUETOOTH_ERROR_NONE;
1234 int _bt_stop_le_scan(const char *sender)
1237 GError *error = NULL;
1239 bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1241 gboolean next_scanning = FALSE;
1242 gboolean need_scan_filter = TRUE;
1244 if (scanner == NULL || scanner->is_scanning == FALSE)
1245 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1247 scanner->is_scanning = FALSE;
1249 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1251 if (scanner->is_scanning == TRUE) {
1252 next_scanning = TRUE;
1253 if (scanner->filter_list == NULL)
1254 need_scan_filter = FALSE;
1258 proxy = _bt_get_adapter_proxy();
1259 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1261 if (next_scanning == TRUE) {
1262 if (scan_filter_enabled == FALSE && need_scan_filter == TRUE) {
1263 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1264 g_variant_new("(ib)", 0, TRUE),
1265 G_DBUS_CALL_FLAGS_NONE,
1269 BT_ERR("scan_filter_clear Fail: %s", error->message);
1270 g_clear_error(&error);
1274 g_variant_unref(ret);
1275 BT_INFO("Enable LE Scan Filter");
1276 scan_filter_enabled = TRUE;
1278 return BLUETOOTH_ERROR_NONE;
1280 if (scan_filter_enabled == TRUE) {
1281 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1282 g_variant_new("(ib)", 0, FALSE),
1283 G_DBUS_CALL_FLAGS_NONE,
1287 BT_ERR("scan_filter_clear Fail: %s", error->message);
1288 g_clear_error(&error);
1292 g_variant_unref(ret);
1293 BT_INFO("Disable LE Scan Filter");
1295 BT_INFO("Just stop LE scan");
1299 ret = g_dbus_proxy_call_sync(proxy, "StopLEDiscovery",
1300 NULL,G_DBUS_CALL_FLAGS_NONE,
1303 BT_ERR("LE Scan stop failed");
1304 return BLUETOOTH_ERROR_INTERNAL;
1307 scan_filter_enabled = FALSE;
1308 is_le_set_scan_parameter = FALSE;
1310 g_variant_unref(ret);
1311 return BLUETOOTH_ERROR_NONE;
1314 void _bt_set_le_scan_status(gboolean mode)
1316 is_le_scanning = mode;
1319 gboolean _bt_is_le_scanning(void)
1321 return is_le_scanning;
1324 void _bt_set_le_scan_type(bt_le_scan_type_t type)
1326 le_scan_type = type;
1329 bt_le_scan_type_t _bt_get_le_scan_type(void)
1331 return le_scan_type;
1334 static gboolean __bt_check_scan_result_uuid(const char *adv_data,
1335 int adv_data_len, const char *svc_uuid, int uuid_len,
1336 const char *uuid_mask, char ad_type)
1342 __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1343 ad_type, &data, &data_len);
1345 _bt_swap_byte_ordering(data, data_len);
1346 for (i = 0; i < data_len; i += uuid_len) {
1347 if (uuid_len > (data_len - i))
1350 if (_bt_byte_arr_cmp_with_mask(data + i,
1351 svc_uuid, uuid_mask, uuid_len) == 0) {
1362 static gboolean __bt_check_scan_result_with_filter(const char *device_address,
1363 const char *adv_data, int adv_data_len,
1364 const char *scan_data, int scan_data_len,
1365 const bt_adapter_le_scanner_t *scanner)
1368 bluetooth_le_scan_filter_t *filter_data = NULL;
1371 gboolean is_matched = FALSE;
1373 if (scanner->filter_list == NULL) {
1374 BT_INFO("This scanner is on Full Scan.");
1378 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1379 filter_data = l->data;
1381 if (filter_data->added_features &
1382 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
1383 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1385 _bt_convert_addr_type_to_string(address,
1386 filter_data->device_address.addr);
1387 if (strncmp(address, device_address,
1388 BT_ADDRESS_STRING_SIZE) != 0)
1392 if (filter_data->added_features &
1393 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
1396 if (__bt_check_scan_result_uuid(adv_data,
1398 (char*)filter_data->service_uuid.data.data,
1399 filter_data->service_uuid.data_len,
1400 (char*)filter_data->service_uuid_mask.data.data,
1401 BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1404 if (__bt_check_scan_result_uuid(adv_data,
1406 (char*)filter_data->service_uuid.data.data,
1407 filter_data->service_uuid.data_len,
1408 (char*)filter_data->service_uuid_mask.data.data,
1409 BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1412 if (__bt_check_scan_result_uuid(adv_data,
1414 (char*)filter_data->service_uuid.data.data,
1415 filter_data->service_uuid.data_len,
1416 (char*)filter_data->service_uuid_mask.data.data,
1417 BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1420 if (__bt_check_scan_result_uuid(adv_data,
1422 (char*)filter_data->service_uuid.data.data,
1423 filter_data->service_uuid.data_len,
1424 (char*)filter_data->service_uuid_mask.data.data,
1425 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1428 if (__bt_check_scan_result_uuid(scan_data,
1430 (char*)filter_data->service_uuid.data.data,
1431 filter_data->service_uuid.data_len,
1432 (char*)filter_data->service_uuid_mask.data.data,
1433 BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1436 if (__bt_check_scan_result_uuid(scan_data,
1438 (char*)filter_data->service_uuid.data.data,
1439 filter_data->service_uuid.data_len,
1440 (char*)filter_data->service_uuid_mask.data.data,
1441 BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1444 if (__bt_check_scan_result_uuid(scan_data,
1446 (char*)filter_data->service_uuid.data.data,
1447 filter_data->service_uuid.data_len,
1448 (char*)filter_data->service_uuid_mask.data.data,
1449 BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1452 if (__bt_check_scan_result_uuid(scan_data,
1454 (char*)filter_data->service_uuid.data.data,
1455 filter_data->service_uuid.data_len,
1456 (char*)filter_data->service_uuid_mask.data.data,
1457 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1461 if (is_matched == FALSE)
1464 if (filter_data->added_features &
1465 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
1468 if (__bt_check_scan_result_uuid(adv_data,
1470 (char*)filter_data->service_solicitation_uuid.data.data,
1471 filter_data->service_solicitation_uuid.data_len,
1472 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1473 BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS)
1476 if (__bt_check_scan_result_uuid(adv_data,
1478 (char*)filter_data->service_solicitation_uuid.data.data,
1479 filter_data->service_solicitation_uuid.data_len,
1480 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1481 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1484 if (__bt_check_scan_result_uuid(scan_data,
1486 (char*)filter_data->service_solicitation_uuid.data.data,
1487 filter_data->service_solicitation_uuid.data_len,
1488 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1489 BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS)
1492 if (__bt_check_scan_result_uuid(scan_data,
1494 (char*)filter_data->service_solicitation_uuid.data.data,
1495 filter_data->service_solicitation_uuid.data_len,
1496 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1497 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1501 if (is_matched == FALSE)
1504 if (filter_data->added_features &
1505 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
1506 char name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX] = {0, };
1511 __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1512 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1515 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1516 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1517 memcpy(name, data, data_len);
1518 name[data_len] = '\0';
1521 if (strncmp(filter_data->device_name,
1522 name, data_len) == 0)
1525 __bt_get_ad_data_by_type((char*)scan_data,
1527 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1530 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1531 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1532 memcpy(name, data, data_len);
1533 name[data_len] = '\0';
1536 if (strncmp(filter_data->device_name,
1537 name, data_len) == 0)
1541 if (is_matched == FALSE)
1544 if (filter_data->added_features &
1545 BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
1550 __bt_get_ad_data_by_type((char*)adv_data,
1552 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1555 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1556 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1557 if (_bt_byte_arr_cmp_with_mask(data,
1558 (char*)filter_data->manufacturer_data.data.data,
1559 (char*)filter_data->manufacturer_data_mask.data.data,
1566 __bt_get_ad_data_by_type((char*)scan_data,
1568 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1571 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1572 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1573 if (_bt_byte_arr_cmp_with_mask(data,
1574 (char*)filter_data->manufacturer_data.data.data,
1575 (char*)filter_data->manufacturer_data_mask.data.data,
1583 if (is_matched == FALSE)
1586 if (filter_data->added_features &
1587 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
1592 __bt_get_ad_data_by_type((char*)adv_data,
1594 BT_LE_AD_TYPE_SERVICE_DATA,
1597 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1598 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1599 if (_bt_byte_arr_cmp_with_mask(data,
1600 (char*)filter_data->service_data.data.data,
1601 (char*)filter_data->service_data_mask.data.data,
1608 __bt_get_ad_data_by_type((char*)scan_data,
1610 BT_LE_AD_TYPE_SERVICE_DATA,
1613 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1614 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1615 if (_bt_byte_arr_cmp_with_mask(data,
1616 (char*)filter_data->service_data.data.data,
1617 (char*)filter_data->service_data_mask.data.data,
1625 if (is_matched == FALSE)
1629 BT_INFO("The scan result is conformable.");
1633 BT_INFO("The scan result is NOT conformable.");
1637 void _bt_send_scan_result_event(const bt_remote_le_dev_info_t *le_dev_info,
1638 const bt_le_adv_info_t *adv_info)
1640 int result = BLUETOOTH_ERROR_NONE;
1642 GVariant *scan_data_param, *adv_data_param;
1644 bt_adapter_le_scanner_t *scanner = NULL;
1645 const char *adv_data = NULL;
1646 int adv_data_len = 0;
1647 const char *scan_data = NULL;
1648 int scan_data_len = 0;
1650 ret_if(le_dev_info == NULL);
1651 if (_bt_get_le_scan_type() == BT_LE_ACTIVE_SCAN)
1652 ret_if(adv_info == NULL);
1654 if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) {
1655 adv_data = le_dev_info->adv_data;
1656 adv_data_len = le_dev_info->adv_data_len;
1657 scan_data = le_dev_info->adv_data;
1660 adv_data = adv_info->data;
1661 adv_data_len = adv_info->data_len;
1662 scan_data = le_dev_info->adv_data;
1663 scan_data_len = le_dev_info->adv_data_len;
1666 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1668 if (scanner->is_scanning == FALSE)
1671 if (__bt_check_scan_result_with_filter(le_dev_info->address,
1672 adv_data, adv_data_len, scan_data, scan_data_len,
1676 adv_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1677 adv_data, adv_data_len, TRUE, NULL, NULL);
1678 scan_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1679 scan_data, scan_data_len, TRUE, NULL, NULL);
1681 param = g_variant_new("(isnnn@ayn@ay)",
1683 le_dev_info->address,
1684 le_dev_info->addr_type,
1691 _bt_send_event_to_dest(scanner->sender, BT_LE_ADAPTER_EVENT,
1692 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, param);
1696 int _bt_add_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
1699 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1700 GError *error = NULL;
1703 if (__bt_is_factory_test_mode()) {
1704 BT_ERR("Unable to add white list in factory binary !!");
1705 return BLUETOOTH_ERROR_NOT_SUPPORT;
1708 BT_CHECK_PARAMETER(device_address, return);
1710 if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
1711 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
1712 return BLUETOOTH_ERROR_INVALID_PARAM;
1714 _bt_convert_addr_type_to_string(address, device_address->addr);
1716 proxy = _bt_get_adapter_proxy();
1717 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1719 ret = g_dbus_proxy_call_sync(proxy, "AddDeviceWhiteList",
1720 g_variant_new("(su)", address, address_type),
1721 G_DBUS_CALL_FLAGS_NONE, -1,
1725 BT_ERR("AddDeviceWhiteList Fail: %s", error->message);
1726 g_clear_error(&error);
1727 return BLUETOOTH_ERROR_INTERNAL;
1731 g_variant_unref(ret);
1732 BT_INFO("Add white list");
1734 return BLUETOOTH_ERROR_NONE;
1737 int _bt_remove_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
1740 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1741 GError *error = NULL;
1744 if (__bt_is_factory_test_mode()) {
1745 BT_ERR("Unable to remove white list in factory binary !!");
1746 return BLUETOOTH_ERROR_NOT_SUPPORT;
1749 BT_CHECK_PARAMETER(device_address, return);
1751 if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
1752 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
1753 return BLUETOOTH_ERROR_INVALID_PARAM;
1755 _bt_convert_addr_type_to_string(address, device_address->addr);
1757 proxy = _bt_get_adapter_proxy();
1758 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1760 ret = g_dbus_proxy_call_sync(proxy, "RemoveDeviceWhiteList",
1761 g_variant_new("(su)", address, address_type),
1762 G_DBUS_CALL_FLAGS_NONE, -1,
1766 BT_ERR("RemoveDeviceWhiteList Fail: %s", error->message);
1767 g_clear_error(&error);
1768 return BLUETOOTH_ERROR_INTERNAL;
1772 g_variant_unref(ret);
1773 BT_INFO("Remove white list");
1775 return BLUETOOTH_ERROR_NONE;
1778 int _bt_clear_white_list(void)
1781 GError *error = NULL;
1784 if (__bt_is_factory_test_mode()) {
1785 BT_ERR("Unable to clear white list in factory binary !!");
1786 return BLUETOOTH_ERROR_NOT_SUPPORT;
1789 proxy = _bt_get_adapter_proxy();
1790 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1792 ret = g_dbus_proxy_call_sync(proxy, "ClearDeviceWhiteList",
1793 NULL,G_DBUS_CALL_FLAGS_NONE,
1797 BT_ERR("ClearDeviceWhiteList Fail: %s", error->message);
1798 g_clear_error(&error);
1799 return BLUETOOTH_ERROR_INTERNAL;
1802 g_variant_unref(ret);
1804 BT_INFO("Clear white list");
1806 return BLUETOOTH_ERROR_NONE;