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>
37 #include "bt-internal-types.h"
38 #include "bt-service-common.h"
39 #include "bt-service-event.h"
40 #include "bt-service-adapter.h"
41 #include "bt-service-adapter-le.h"
44 #define BT_ADV_INTERVAL_MIN 20 /* msec */
45 #define BT_ADV_INTERVAL_MAX 10240
46 #define BT_ADV_INTERVAL_SPLIT 0.625
47 #define BT_DEFAULT_ADV_MIN_INTERVAL 500
48 #define BT_DEFAULT_ADV_MAX_INTERVAL 500
49 #define BT_ADV_FILTER_POLICY_DEFAULT 0x00
50 #define BT_ADV_TYPE_DEFAULT 0x00
51 #define BT_ADV_FILTER_POLICY_ALLOW_SCAN_CONN_WL_ONLY 0x03
57 } bt_adapter_le_feature_info_t;
62 gboolean is_advertising;
63 } bt_adapter_le_adv_slot_t;
69 } bt_adapter_le_scanner_t;
71 static bluetooth_advertising_params_t adv_params = {
72 BT_DEFAULT_ADV_MIN_INTERVAL,
73 BT_DEFAULT_ADV_MAX_INTERVAL,
74 BT_ADV_FILTER_POLICY_DEFAULT,
76 static bluetooth_advertising_data_t adv_data = { {0} };
77 static int adv_data_len;
78 static bluetooth_scan_resp_data_t resp_data = { {0} };
79 static int resp_data_len;
81 static bt_adapter_le_feature_info_t le_feature_info = { 1, 0, 0 };
82 static bt_adapter_le_adv_slot_t *le_adv_slot = NULL;
84 GSList *scanner_list = NULL;
85 static gboolean is_le_set_scan_parameter = FALSE;
86 static gboolean is_le_scanning = FALSE;
87 static gboolean scan_filter_enabled = FALSE;
88 static bt_le_scan_type_t le_scan_type = BT_LE_PASSIVE_SCAN;
90 void __bt_free_le_adv_slot(void)
94 if (le_adv_slot == NULL)
97 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
98 if (le_adv_slot[i].sender)
99 g_free(le_adv_slot[i].sender);
105 int _bt_service_adapter_le_init(void)
107 le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
109 return BLUETOOTH_ERROR_NONE;
112 void _bt_service_adapter_le_deinit(void)
114 __bt_free_le_adv_slot();
117 gboolean _bt_update_le_feature_support(const char *item, const char *value)
119 if (item== NULL || value == NULL)
122 if (g_strcmp0(item, "adv_inst_max") == 0) {
123 if (atoi(value) != le_feature_info.adv_inst_max) {
124 __bt_free_le_adv_slot();
125 le_feature_info.adv_inst_max = atoi(value);
126 le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
128 } else if (g_strcmp0(item, "rpa_offloading") == 0) {
129 le_feature_info.rpa_offloading = atoi(value);
130 } else if (g_strcmp0(item, "max_filter") == 0) {
131 le_feature_info.max_filter = atoi(value);
133 BT_DBG("No registered item");
140 static gboolean __bt_is_factory_test_mode(void)
143 #ifdef ENABLE_TIZEN_2_4
144 if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
145 BT_ERR("Get the DUT Mode fail");
150 BT_INFO("DUT Test Mode !!");
157 int __bt_get_available_adv_slot_id(const char *sender, int adv_handle, gboolean use_reserved_slot)
161 if (le_adv_slot == NULL)
164 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
165 if (le_adv_slot[i].sender == NULL)
167 if ((g_strcmp0(le_adv_slot[i].sender, sender) == 0) && (le_adv_slot[i].adv_handle == adv_handle))
171 if (le_feature_info.adv_inst_max <= 2)
173 else if (le_feature_info.adv_inst_max > 2 && use_reserved_slot == TRUE)
178 for (; i < le_feature_info.adv_inst_max; i++) {
179 if (le_adv_slot[i].sender == NULL)
186 void __bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id)
188 if (le_adv_slot[slot_id].sender == NULL) {
189 le_adv_slot[slot_id].sender = strdup(sender);
190 le_adv_slot[slot_id].adv_handle = adv_handle;
194 void __bt_unregister_adv_slot_owner(int slot_id)
196 g_free(le_adv_slot[slot_id].sender);
197 le_adv_slot[slot_id].sender = NULL;
198 le_adv_slot[slot_id].adv_handle = 0;
201 const char* _bt_get_adv_slot_owner(int slot_id)
203 if (le_adv_slot == NULL)
206 return le_adv_slot[slot_id].sender;
209 int _bt_get_adv_slot_adv_handle(int slot_id)
211 if (le_adv_slot == NULL)
214 return le_adv_slot[slot_id].adv_handle;
217 void _bt_set_advertising_status(int slot_id, gboolean mode)
219 le_adv_slot[slot_id].is_advertising = mode;
222 gboolean _bt_is_advertising(void)
224 gboolean status = FALSE;
227 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
228 if (le_adv_slot[i].is_advertising == TRUE)
235 void _bt_stop_advertising_by_terminated_process(const char* terminated_name)
239 if (le_adv_slot == NULL)
242 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
243 if (le_adv_slot[i].sender != NULL) {
244 if (strcasecmp(terminated_name, le_adv_slot[i].sender) == 0) {
245 BT_ERR("Stop advertising by terminated process(%s).", terminated_name);
246 _bt_set_advertising(terminated_name, le_adv_slot[i].adv_handle, FALSE, FALSE);
252 gboolean _bt_get_advertising_params(bluetooth_advertising_params_t *params)
257 memcpy(params, &adv_params, sizeof(bluetooth_advertising_params_t));
262 int _bt_set_advertising(const char *sender, int adv_handle, gboolean enable, gboolean use_reserved_slot)
265 GError *error = NULL;
269 if (__bt_is_factory_test_mode()) {
270 BT_ERR("Unable to start advertising in factory binary !!");
271 return BLUETOOTH_ERROR_NOT_SUPPORT;
274 if (_bt_adapter_get_status() != BT_ACTIVATED &&
275 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
276 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
279 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
281 BT_ERR("There is NO available slot!!");
282 return BLUETOOTH_ERROR_NO_RESOURCES;
285 if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
286 return BLUETOOTH_ERROR_IN_PROGRESS;
288 if (le_adv_slot[slot_id].sender != NULL && le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
289 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
291 proxy = _bt_get_adapter_proxy();
292 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
294 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
295 g_variant_new("(bi)", enable, slot_id),
296 G_DBUS_CALL_FLAGS_NONE,
302 BT_ERR("SetAdvertising Fail: %s", error->message);
303 g_clear_error(&error);
304 return BLUETOOTH_ERROR_INTERNAL;
308 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
310 le_adv_slot[slot_id].is_advertising = enable;
311 BT_INFO("Set advertising [%d]", enable);
314 g_variant_unref(ret);
316 return BLUETOOTH_ERROR_NONE;
319 int _bt_set_custom_advertising(const char *sender, int adv_handle,
320 gboolean enable, bluetooth_advertising_params_t *params, gboolean use_reserved_slot)
324 GError *error = NULL;
329 BT_CHECK_PARAMETER(params, return);
331 if (__bt_is_factory_test_mode()) {
332 BT_ERR("Unable to start advertising in factory binary !!");
333 return BLUETOOTH_ERROR_NOT_SUPPORT;
336 if (_bt_adapter_get_status() != BT_ACTIVATED &&
337 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
338 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
341 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
343 BT_ERR("There is NO available slot!!");
344 return BLUETOOTH_ERROR_NO_RESOURCES;
347 if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
348 return BLUETOOTH_ERROR_IN_PROGRESS;
350 if (le_adv_slot[slot_id].sender != NULL && le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
351 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
353 proxy = _bt_get_adapter_proxy();
354 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
356 if (params->interval_min > params->interval_max ||
357 params->interval_min < BT_ADV_INTERVAL_MIN ||
358 params->interval_max > BT_ADV_INTERVAL_MAX)
359 return BLUETOOTH_ERROR_INVALID_PARAM;
361 if (params->filter_policy > BLUETOOTH_ALLOW_SCAN_CONN_WHITE_LIST)
362 return BLUETOOTH_ERROR_INVALID_PARAM;
364 if (params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_HIGH ||
365 params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_LOW ||
366 params->type == BLUETOOTH_ADV_NON_CONNECTABLE)
367 return BLUETOOTH_ERROR_NOT_SUPPORT;
369 min = params->interval_min / BT_ADV_INTERVAL_SPLIT;
370 max = params->interval_max / BT_ADV_INTERVAL_SPLIT;
372 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingParameters",
373 g_variant_new("(uuuui)", min, max,
374 params->filter_policy, params->type,
375 slot_id), G_DBUS_CALL_FLAGS_NONE,
379 BT_ERR("SetAdvertisingParameters Fail: %s", error->message);
380 g_clear_error(&error);
381 return BLUETOOTH_ERROR_INTERNAL;
384 adv_params.interval_min = params->interval_min;
385 adv_params.interval_max = params->interval_max;
386 adv_params.filter_policy = params->filter_policy;
387 adv_params.type= params->type;
390 g_variant_unref(ret);
392 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
393 g_variant_new("(bi)", enable, slot_id),
394 G_DBUS_CALL_FLAGS_NONE,
400 BT_ERR("SetAdvertising Fail: %s", error->message);
401 g_clear_error(&error);
402 return BLUETOOTH_ERROR_INTERNAL;
406 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
408 __bt_unregister_adv_slot_owner(slot_id);
410 le_adv_slot[slot_id].is_advertising = enable;
411 BT_INFO_C("Set advertising [%d]", enable);
413 g_variant_unref(ret);
415 return BLUETOOTH_ERROR_NONE;
418 static int __bt_get_ad_data_by_type(char *in_data, int in_len,
419 char in_type, char **data, int *data_len)
421 if (in_data == NULL || data == NULL || data_len == NULL)
422 return BLUETOOTH_ERROR_INTERNAL;
425 return BLUETOOTH_ERROR_INTERNAL;
431 for (i = 0; i < in_len; i++) {
433 if (len <= 0 || i + 1 >= in_len) {
434 BT_ERR("Invalid advertising data");
435 return BLUETOOTH_ERROR_INTERNAL;
438 type = in_data[i + 1];
439 if (type == in_type) {
449 if (i + len > in_len) {
450 BT_ERR("Invalid advertising data");
451 return BLUETOOTH_ERROR_INTERNAL;
452 } else if (len == 0) {
453 BT_DBG("AD Type 0x%02x data is not set", in_type);
456 return BLUETOOTH_ERROR_NONE;
459 *data = g_memdup(&in_data[i], len);
461 return BLUETOOTH_ERROR_OUT_OF_MEMORY;
464 return BLUETOOTH_ERROR_NONE;
467 int _bt_get_advertising_data(bluetooth_advertising_data_t *adv, int *length)
469 BT_CHECK_PARAMETER(adv, return);
470 BT_CHECK_PARAMETER(length, return);
472 memcpy(adv, &adv_data, sizeof(adv_data));
473 *length = adv_data_len;
475 return BLUETOOTH_ERROR_NONE;
478 int _bt_set_advertising_data(const char *sender, int adv_handle,
479 bluetooth_advertising_data_t *adv, int length, gboolean use_reserved_slot)
482 GError *error = NULL;
483 GVariant *ret, *ad_data, *param = NULL;
484 GVariant *temp = NULL;
485 GVariantBuilder *builder;
487 char *old_mdata = NULL;
488 char *new_mdata = NULL;
493 if (__bt_is_factory_test_mode()) {
494 BT_ERR("Unable to set advertising data in factory binary !!");
495 return BLUETOOTH_ERROR_NOT_SUPPORT;
498 BT_CHECK_PARAMETER(adv, return);
500 if (_bt_adapter_get_status() != BT_ACTIVATED &&
501 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
502 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
505 proxy = _bt_get_adapter_proxy();
506 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
508 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
510 BT_ERR("There is NO available slot!!");
511 return BLUETOOTH_ERROR_NO_RESOURCES;
514 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
515 for (i = 0; i < length; i++) {
516 g_variant_builder_add(builder, "y", adv->data[i]);
519 temp = g_variant_new("ay", builder);
520 g_variant_builder_unref(builder);
521 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingData",
522 g_variant_new("(@ayi)", temp, slot_id),
523 G_DBUS_CALL_FLAGS_NONE,
527 BT_ERR("SetAdvertisingData Fail: %s", error->message);
528 g_clear_error(&error);
529 return BLUETOOTH_ERROR_INTERNAL;
532 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
534 __bt_get_ad_data_by_type((char *)adv_data.data, adv_data_len, 0xff,
535 &old_mdata, &old_len);
536 __bt_get_ad_data_by_type((char *)adv->data, length, 0xff,
537 &new_mdata, &new_len);
538 if (old_len != new_len ||
539 (old_mdata && new_mdata &&
540 memcmp(old_mdata, new_mdata, new_len))) {
541 ad_data = g_variant_new_from_data((const GVariantType *)"ay",
542 new_mdata, new_len, TRUE, NULL, NULL);
543 param = g_variant_new("(@ay)", ad_data);
544 _bt_send_event(BT_ADAPTER_EVENT,
545 BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
551 memset(&adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
552 memcpy(&adv_data, adv, length);
553 adv_data_len = length;
555 BT_INFO("Set advertising data");
557 g_variant_unref(ret);
559 return BLUETOOTH_ERROR_NONE;
562 int _bt_get_scan_response_data(bluetooth_scan_resp_data_t *response, int *length)
564 BT_CHECK_PARAMETER(response, return);
565 BT_CHECK_PARAMETER(length, return);
567 memcpy(response, &resp_data, sizeof(resp_data));
568 *length = resp_data_len;
570 return BLUETOOTH_ERROR_NONE;
573 int _bt_set_scan_response_data(const char *sender, int adv_handle,
574 bluetooth_scan_resp_data_t *response, int length, gboolean use_reserved_slot)
577 GError *error = NULL;
578 GVariant *ret, *scan_data, *param = NULL;
579 GVariant *temp = NULL;
580 GVariantBuilder *builder;
582 char *old_mdata = NULL;
583 char *new_mdata = NULL;
588 if (__bt_is_factory_test_mode()) {
589 BT_ERR("Unable to set scan response list in factory binary !!");
590 return BLUETOOTH_ERROR_NOT_SUPPORT;
593 BT_CHECK_PARAMETER(response, return);
595 if (_bt_adapter_get_status() != BT_ACTIVATED &&
596 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
597 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
600 proxy = _bt_get_adapter_proxy();
601 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
603 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
605 BT_ERR("There is NO available slot!!");
606 return BLUETOOTH_ERROR_NO_RESOURCES;
608 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
609 for (i = 0; i < length; i++) {
610 g_variant_builder_add(builder, "y", response->data[i]);
613 temp = g_variant_new("ay", builder);
614 g_variant_builder_unref(builder);
615 ret = g_dbus_proxy_call_sync(proxy, "SetScanRespData",
616 g_variant_new("(@ayi)", temp, slot_id),
617 G_DBUS_CALL_FLAGS_NONE,
621 BT_ERR("SetScanRespData Fail: %s", error->message);
622 g_clear_error(&error);
623 return BLUETOOTH_ERROR_INTERNAL;
626 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
628 /* Compare with previous scan resp data */
629 __bt_get_ad_data_by_type((char *)resp_data.data, resp_data_len, 0xff,
630 &old_mdata, &old_len);
631 __bt_get_ad_data_by_type((char *)response->data, length, 0xff,
632 &new_mdata, &new_len);
633 if (old_len != new_len ||
634 (old_mdata && new_mdata &&
635 memcmp(old_mdata, new_mdata, new_len))) {
636 scan_data = g_variant_new_from_data((const GVariantType *)"ay",
637 new_mdata, new_len, TRUE, NULL, NULL);
638 param = g_variant_new("(@ay)", scan_data);
639 _bt_send_event(BT_ADAPTER_EVENT,
640 BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
646 memset(&resp_data, 0x00, sizeof(bluetooth_scan_resp_data_t));
647 memcpy(&resp_data, response, length);
648 resp_data_len = length;
651 g_variant_unref(ret);
652 BT_INFO("Set scan response data");
653 return BLUETOOTH_ERROR_NONE;
656 int _bt_set_scan_parameters(bluetooth_le_scan_params_t *params)
659 GError *error = NULL;
664 BT_CHECK_PARAMETER(params, return);
666 if (_bt_adapter_get_status() != BT_ACTIVATED &&
667 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
668 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
671 proxy = _bt_get_adapter_proxy();
672 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
674 if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
675 return BLUETOOTH_ERROR_INVALID_PARAM;
677 if (params->window < BT_LE_SCAN_WINDOW_MIN || params->window > BT_LE_SCAN_WINDOW_MAX)
678 return BLUETOOTH_ERROR_INVALID_PARAM;
680 if (params->window > params->interval)
681 return BLUETOOTH_ERROR_INVALID_PARAM;
683 itv = params->interval / BT_ADV_INTERVAL_SPLIT;
684 win = params->window / BT_ADV_INTERVAL_SPLIT;
686 ret = g_dbus_proxy_call_sync(proxy, "SetScanParameters",
687 g_variant_new("(uuu)", params->type, itv, win),
688 G_DBUS_CALL_FLAGS_NONE, -1,
692 BT_ERR("SetScanParameters Fail: %s", error->message);
693 g_clear_error(&error);
694 return BLUETOOTH_ERROR_INTERNAL;
697 _bt_set_le_scan_type(params->type);
699 is_le_set_scan_parameter = TRUE;
702 g_variant_unref(ret);
703 BT_INFO("Set scan parameters");
704 return BLUETOOTH_ERROR_NONE;
707 bt_adapter_le_scanner_t* __bt_find_scanner_from_list(const char *sender)
710 bt_adapter_le_scanner_t *scanner;
712 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
714 if (g_strcmp0(scanner->sender, sender) == 0)
721 int __bt_get_available_scan_filter_slot_id(void)
724 bt_adapter_le_scanner_t *scanner;
726 bluetooth_le_scan_filter_t *filter_data;
727 gboolean *slot_check_list;
730 if (le_feature_info.max_filter == 0) {
731 BT_ERR("Scan filter is NOT Supported");
734 slot_check_list = g_malloc0(sizeof(gboolean) * le_feature_info.max_filter);
736 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
738 for (fl = scanner->filter_list; fl != NULL; fl = g_slist_next(fl)) {
739 filter_data = fl->data;
740 if (filter_data->slot_id < le_feature_info.max_filter) {
741 slot_check_list[filter_data->slot_id] = TRUE;
746 for (i = 0; i < le_feature_info.max_filter; i++) {
747 if (slot_check_list[i] == FALSE) {
748 g_free(slot_check_list);
753 BT_ERR("There is NO available slot for scan filter.");
754 g_free(slot_check_list);
758 int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id)
761 GError *error = NULL;
762 GVariant *ret, *param;
763 GVariant *arr_uuid_param, *arr_uuid_mask_param;
764 GVariant *arr_data_param, *arr_data_mask_param;
766 GArray *arr_uuid_mask;
768 GArray *arr_data_mask;
769 bt_adapter_le_scanner_t *scanner = NULL;
770 bluetooth_le_scan_filter_t *filter_data = NULL;
771 int feature_selection = 0;
773 *slot_id = __bt_get_available_scan_filter_slot_id();
775 return BLUETOOTH_ERROR_NO_RESOURCES;
777 proxy = _bt_get_adapter_proxy();
778 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
780 arr_uuid = g_array_new(TRUE, TRUE, sizeof(guint8));
781 arr_uuid_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
782 arr_data = g_array_new(TRUE, TRUE, sizeof(guint8));
783 arr_data_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
785 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
786 arr_uuid, filter->service_uuid.data_len * sizeof(guint8), TRUE, NULL, NULL);
787 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
788 arr_uuid_mask, filter->service_uuid_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
789 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
790 arr_data, filter->service_data.data_len * sizeof(guint8), TRUE, NULL, NULL);
791 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
792 arr_data_mask, filter->service_data_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
794 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
795 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
796 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
798 _bt_convert_addr_type_to_string(address, filter->device_address.addr);
800 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
802 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
803 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS, // filter_type
804 slot_id, // filter_index
806 0, // company_id_mask
807 arr_uuid_param, // p_uuid
808 arr_uuid_mask_param, // p_uuid_mask
811 arr_data_param, // p_data
812 arr_data_mask_param); // p_mask
814 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
815 param, G_DBUS_CALL_FLAGS_NONE,
819 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
820 g_clear_error(&error);
823 g_variant_unref(ret);
826 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
827 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME;
829 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
831 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
832 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME, // filter_type
833 slot_id, // filter_index
835 0, // company_id_mask
836 arr_uuid_param, // p_uuid
837 arr_uuid_mask_param, // p_uuid_mask
838 filter->device_name, // string
840 arr_data_param, // p_data
841 arr_data_mask_param);
843 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
844 param, G_DBUS_CALL_FLAGS_NONE,
848 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
849 g_clear_error(&error);
852 g_variant_unref(ret);
855 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
856 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID;
858 g_array_append_vals(arr_uuid, filter->service_uuid.data.data, filter->service_uuid.data_len * sizeof(guint8));
859 g_array_append_vals(arr_uuid_mask, filter->service_uuid_mask.data.data, filter->service_uuid_mask.data_len * sizeof(guint8));
861 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
862 arr_uuid, filter->service_uuid.data_len * sizeof(guint8), TRUE, NULL, NULL);
863 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
864 arr_uuid, filter->service_uuid_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
866 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
868 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
869 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID, // filter_type
870 slot_id, // filter_index
872 0, // company_id_mask
873 arr_uuid_param, // p_uuid
874 arr_uuid_mask_param, // p_uuid_mask
877 arr_data_param, // p_data
878 arr_data_mask_param);
880 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
881 param, G_DBUS_CALL_FLAGS_NONE,
885 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
886 g_clear_error(&error);
889 g_variant_unref(ret);
892 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
893 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
895 g_array_append_vals(arr_uuid, filter->service_solicitation_uuid.data.data, filter->service_solicitation_uuid.data_len * sizeof(guint8));
896 g_array_append_vals(arr_uuid_mask, filter->service_solicitation_uuid_mask.data.data, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8));
898 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
899 arr_uuid, filter->service_solicitation_uuid.data_len * sizeof(guint8), TRUE, NULL, NULL);
900 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
901 arr_uuid, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
903 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
905 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
906 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID, // filter_type
907 slot_id, // filter_index
909 0, // company_id_mask
910 arr_uuid_param, // p_uuid
911 arr_uuid_mask_param, // p_uuid_mask
914 arr_data_param, // p_data
915 arr_data_mask_param);
917 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
918 G_DBUS_CALL_FLAGS_NONE,
922 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
923 g_clear_error(&error);
926 g_variant_unref(ret);
929 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
930 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
932 g_array_append_vals(arr_data, filter->service_data.data.data, filter->service_data.data_len * sizeof(guint8));
933 g_array_append_vals(arr_data_mask, filter->service_data_mask.data.data, filter->service_data_mask.data_len * sizeof(guint8));
935 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
936 arr_uuid, filter->service_data.data_len * sizeof(guint8), TRUE, NULL, NULL);
937 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
938 arr_uuid, filter->service_data_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
940 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
942 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
943 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA, // filter_type
944 slot_id, // filter_index
946 0, // company_id_mask
947 arr_uuid_param, // p_uuid
948 arr_uuid_mask_param, // p_uuid_mask
951 arr_data_param, // p_data
952 arr_data_mask_param);
954 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
955 G_DBUS_CALL_FLAGS_NONE,
959 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
960 g_clear_error(&error);
963 g_variant_unref(ret);
966 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
967 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
969 g_array_append_vals(arr_data, filter->manufacturer_data.data.data, filter->manufacturer_data.data_len * sizeof(guint8));
970 g_array_append_vals(arr_data_mask, filter->manufacturer_data_mask.data.data, filter->manufacturer_data_mask.data_len * sizeof(guint8));
972 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
973 arr_uuid, filter->manufacturer_data.data_len * sizeof(guint8), TRUE, NULL, NULL);
974 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
975 arr_uuid, filter->manufacturer_data_mask.data_len * sizeof(guint8), TRUE, NULL, NULL);
977 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
979 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
980 BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA, // filter_type
981 slot_id, // filter_index
982 filter->manufacturer_id, // company_id
983 0xFFFF, // company_id_mask
984 arr_uuid_param, // p_uuid
985 arr_uuid_mask_param, // p_uuid_mask
988 arr_data_param, // p_data
989 arr_data_mask_param);
991 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
992 G_DBUS_CALL_FLAGS_NONE,
996 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
997 g_clear_error(&error);
1000 g_variant_unref(ret);
1003 g_array_free(arr_uuid, TRUE);
1004 g_array_free(arr_uuid_mask, TRUE);
1005 g_array_free(arr_data, TRUE);
1006 g_array_free(arr_data_mask, TRUE);
1008 BT_DBG("Filter selection %.2x", feature_selection);
1010 param = g_variant_new("(iiiiiiiiiiii)",
1012 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1013 slot_id, // filter_index
1014 feature_selection, // feat_seln
1015 0, // list_logic_type (OR - 0x00, AND - 0x01)
1016 1, // filt_logic_type (OR - 0x00, AND - 0x01)
1017 -127, // rssi_high_thres
1018 -127, // rssi_low_thres
1019 0, // dely_mode (Immediate - 0x00, on found - 0x01, batched - 0x02)
1022 0); // found_timeout_cnt
1023 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_param_setup",
1024 param, G_DBUS_CALL_FLAGS_NONE,
1028 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1029 g_clear_error(&error);
1032 scanner = __bt_find_scanner_from_list(sender);
1033 if (scanner == NULL) {
1034 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1035 scanner->sender = strdup(sender);
1036 scanner_list = g_slist_append(scanner_list, scanner);
1039 filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
1040 memcpy(filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
1041 filter_data->slot_id = *slot_id;
1043 scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
1046 g_variant_unref(ret);
1047 return BLUETOOTH_ERROR_NONE;
1050 int _bt_unregister_scan_filter(const char *sender, int slot_id)
1053 GError *error = NULL;
1055 bt_adapter_le_scanner_t *scanner = NULL;
1056 bluetooth_le_scan_filter_t *filter_data = NULL;
1058 gboolean is_slot_id_found = FALSE;
1060 scanner = __bt_find_scanner_from_list(sender);
1061 if (scanner == NULL) {
1062 BT_ERR("There is NO available scanner.");
1063 return BLUETOOTH_ERROR_NOT_FOUND;
1066 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1067 filter_data = l->data;
1068 if (filter_data->slot_id == slot_id) {
1069 is_slot_id_found = TRUE;
1073 if (is_slot_id_found == FALSE) {
1074 BT_ERR("There is NO registered slot.");
1075 return BLUETOOTH_ERROR_NOT_FOUND;
1078 proxy = _bt_get_adapter_proxy();
1079 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1081 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1082 g_variant_new("(ii)", 0, slot_id),
1083 G_DBUS_CALL_FLAGS_NONE,
1087 BT_ERR("scan_filter_clear Fail: %s", error->message);
1088 g_clear_error(&error);
1091 scanner->filter_list = g_slist_remove(scanner->filter_list, filter_data);
1092 g_free(filter_data);
1095 g_variant_unref(ret);
1096 return BLUETOOTH_ERROR_NONE;
1099 int _bt_unregister_all_scan_filters(const char *sender)
1102 GError *error = NULL;
1104 bt_adapter_le_scanner_t *scanner = NULL;
1105 bluetooth_le_scan_filter_t *filter_data = NULL;
1108 scanner = __bt_find_scanner_from_list(sender);
1109 if (scanner == NULL) {
1110 BT_ERR("There is NO available scanner.");
1111 return BLUETOOTH_ERROR_NOT_FOUND;
1114 proxy = _bt_get_adapter_proxy();
1115 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1117 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1118 filter_data = l->data;
1120 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1121 g_variant_new("(ii)", 0, filter_data->slot_id),
1122 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1125 BT_ERR("scan_filter_clear Fail: %s", error->message);
1126 g_clear_error(&error);
1129 g_variant_unref(ret);
1132 g_slist_free_full(scanner->filter_list, g_free);
1133 scanner->filter_list = NULL;
1135 return BLUETOOTH_ERROR_NONE;
1138 int _bt_start_le_scan(const char *sender)
1141 GError *error = NULL;
1143 bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1145 if (scanner == NULL) {
1146 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1147 scanner->sender = strdup(sender);
1148 scanner_list = g_slist_append(scanner_list, scanner);
1151 if (scanner->is_scanning == TRUE) {
1152 BT_ERR("BT is already in LE scanning");
1153 return BLUETOOTH_ERROR_IN_PROGRESS;
1156 proxy = _bt_get_adapter_proxy();
1157 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1159 if (_bt_is_le_scanning()) {
1160 if (scan_filter_enabled == TRUE) {
1161 if (scanner->filter_list == NULL) {
1162 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1163 g_variant_new("(ib)", 0, FALSE),
1164 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1167 BT_ERR("scan_filter_clear Fail: %s", error->message);
1168 g_clear_error(&error);
1172 g_variant_unref(ret);
1173 BT_INFO("Disable LE Scan Filter");
1174 scan_filter_enabled = FALSE;
1176 BT_INFO("LE Filter Scan is continue");
1179 BT_INFO("LE Full Scan is already on progress");
1182 scanner->is_scanning = TRUE;
1183 return BLUETOOTH_ERROR_NONE;
1185 if (is_le_set_scan_parameter == FALSE) {
1186 /* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
1187 bluetooth_le_scan_params_t scan_params;
1188 scan_params.type = 1;
1189 scan_params.interval = 5000;
1190 scan_params.window = 500;
1191 _bt_set_scan_parameters(&scan_params);
1194 if (scanner->filter_list == NULL) {
1195 BT_INFO("Start LE Full Scan");
1196 scan_filter_enabled = FALSE;
1198 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1199 g_variant_new("(ib)", 0, TRUE),
1200 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1203 BT_ERR("scan_filter_clear Fail: %s", error->message);
1204 g_clear_error(&error);
1208 g_variant_unref(ret);
1209 BT_INFO("Enable LE Scan Filter");
1210 scan_filter_enabled = TRUE;
1214 ret = g_dbus_proxy_call_sync(proxy, "StartLEDiscovery",
1215 NULL,G_DBUS_CALL_FLAGS_NONE,
1219 BT_ERR("StartLEDiscovery Fail: %s", error->message);
1220 g_clear_error(&error);
1221 return BLUETOOTH_ERROR_INTERNAL;
1225 g_variant_unref(ret);
1227 scanner->is_scanning = TRUE;
1228 return BLUETOOTH_ERROR_NONE;
1231 int _bt_stop_le_scan(const char *sender)
1234 GError *error = NULL;
1236 bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1238 gboolean next_scanning = FALSE;
1239 gboolean need_scan_filter = TRUE;
1241 if (scanner == NULL || scanner->is_scanning == FALSE)
1242 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1244 scanner->is_scanning = FALSE;
1246 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1248 if (scanner->is_scanning == TRUE) {
1249 next_scanning = TRUE;
1250 if (scanner->filter_list == NULL)
1251 need_scan_filter = FALSE;
1255 proxy = _bt_get_adapter_proxy();
1256 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1258 if (next_scanning == TRUE) {
1259 if (scan_filter_enabled == FALSE && need_scan_filter == TRUE) {
1260 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1261 g_variant_new("(ib)", 0, TRUE),
1262 G_DBUS_CALL_FLAGS_NONE,
1266 BT_ERR("scan_filter_clear Fail: %s", error->message);
1267 g_clear_error(&error);
1271 g_variant_unref(ret);
1272 BT_INFO("Enable LE Scan Filter");
1273 scan_filter_enabled = TRUE;
1275 return BLUETOOTH_ERROR_NONE;
1277 if (scan_filter_enabled == TRUE) {
1278 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1279 g_variant_new("(ib)", 0, FALSE),
1280 G_DBUS_CALL_FLAGS_NONE,
1284 BT_ERR("scan_filter_clear Fail: %s", error->message);
1285 g_clear_error(&error);
1289 g_variant_unref(ret);
1290 BT_INFO("Disable LE Scan Filter");
1292 BT_INFO("Just stop LE scan");
1296 ret = g_dbus_proxy_call_sync(proxy, "StopLEDiscovery",
1297 NULL,G_DBUS_CALL_FLAGS_NONE,
1300 BT_ERR("LE Scan stop failed");
1301 return BLUETOOTH_ERROR_INTERNAL;
1304 scan_filter_enabled = FALSE;
1305 is_le_set_scan_parameter = FALSE;
1307 g_variant_unref(ret);
1308 return BLUETOOTH_ERROR_NONE;
1311 void _bt_disable_all_scanner_status(void)
1314 bt_adapter_le_scanner_t *scanner;
1316 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1318 scanner->is_scanning = FALSE;
1322 void _bt_set_le_scan_status(gboolean mode)
1324 is_le_scanning = mode;
1327 gboolean _bt_is_le_scanning(void)
1329 return is_le_scanning;
1332 void _bt_set_le_scan_type(bt_le_scan_type_t type)
1334 le_scan_type = type;
1337 bt_le_scan_type_t _bt_get_le_scan_type(void)
1339 return le_scan_type;
1342 static gboolean __bt_check_scan_result_uuid(const char *adv_data,
1343 int adv_data_len, const char *svc_uuid, int uuid_len,
1344 const char *uuid_mask, char ad_type)
1350 __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1351 ad_type, &data, &data_len);
1353 _bt_swap_byte_ordering(data, data_len);
1354 for (i = 0; i < data_len; i += uuid_len) {
1355 if (uuid_len > (data_len - i))
1358 if (_bt_byte_arr_cmp_with_mask(data + i,
1359 svc_uuid, uuid_mask, uuid_len) == 0) {
1370 static gboolean __bt_check_scan_result_with_filter(const char *device_address,
1371 const char *adv_data, int adv_data_len,
1372 const char *scan_data, int scan_data_len,
1373 const bt_adapter_le_scanner_t *scanner)
1376 bluetooth_le_scan_filter_t *filter_data = NULL;
1379 gboolean is_matched = FALSE;
1381 if (scanner->filter_list == NULL) {
1382 BT_INFO("This scanner is on Full Scan.");
1386 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1387 filter_data = l->data;
1389 if (filter_data->added_features &
1390 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
1391 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1393 _bt_convert_addr_type_to_string(address,
1394 filter_data->device_address.addr);
1395 if (strncmp(address, device_address,
1396 BT_ADDRESS_STRING_SIZE) != 0)
1400 if (filter_data->added_features &
1401 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
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_INCOMP_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_COMP_LIST_16_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_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1428 if (__bt_check_scan_result_uuid(adv_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_COMP_LIST_128_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_INCOMP_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_COMP_LIST_16_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_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1460 if (__bt_check_scan_result_uuid(scan_data,
1462 (char*)filter_data->service_uuid.data.data,
1463 filter_data->service_uuid.data_len,
1464 (char*)filter_data->service_uuid_mask.data.data,
1465 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1469 if (is_matched == FALSE)
1472 if (filter_data->added_features &
1473 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
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_16_BIT_SERVICE_SOLICITATION_UUIDS)
1484 if (__bt_check_scan_result_uuid(adv_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_128_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_16_BIT_SERVICE_SOLICITATION_UUIDS)
1500 if (__bt_check_scan_result_uuid(scan_data,
1502 (char*)filter_data->service_solicitation_uuid.data.data,
1503 filter_data->service_solicitation_uuid.data_len,
1504 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1505 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1509 if (is_matched == FALSE)
1512 if (filter_data->added_features &
1513 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
1514 char name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX] = {0, };
1519 __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1520 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1523 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1524 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1525 memcpy(name, data, data_len);
1526 name[data_len] = '\0';
1529 if (strncmp(filter_data->device_name,
1530 name, data_len) == 0)
1533 __bt_get_ad_data_by_type((char*)scan_data,
1535 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1538 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1539 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1540 memcpy(name, data, data_len);
1541 name[data_len] = '\0';
1544 if (strncmp(filter_data->device_name,
1545 name, data_len) == 0)
1549 if (is_matched == FALSE)
1552 if (filter_data->added_features &
1553 BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
1558 __bt_get_ad_data_by_type((char*)adv_data,
1560 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1563 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1564 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1565 if (_bt_byte_arr_cmp_with_mask(data,
1566 (char*)filter_data->manufacturer_data.data.data,
1567 (char*)filter_data->manufacturer_data_mask.data.data,
1574 __bt_get_ad_data_by_type((char*)scan_data,
1576 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1579 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1580 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1581 if (_bt_byte_arr_cmp_with_mask(data,
1582 (char*)filter_data->manufacturer_data.data.data,
1583 (char*)filter_data->manufacturer_data_mask.data.data,
1591 if (is_matched == FALSE)
1594 if (filter_data->added_features &
1595 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
1600 __bt_get_ad_data_by_type((char*)adv_data,
1602 BT_LE_AD_TYPE_SERVICE_DATA,
1605 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1606 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1607 if (_bt_byte_arr_cmp_with_mask(data,
1608 (char*)filter_data->service_data.data.data,
1609 (char*)filter_data->service_data_mask.data.data,
1616 __bt_get_ad_data_by_type((char*)scan_data,
1618 BT_LE_AD_TYPE_SERVICE_DATA,
1621 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1622 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1623 if (_bt_byte_arr_cmp_with_mask(data,
1624 (char*)filter_data->service_data.data.data,
1625 (char*)filter_data->service_data_mask.data.data,
1633 if (is_matched == FALSE)
1637 BT_INFO("The scan result is conformable.");
1641 BT_INFO("The scan result is NOT conformable.");
1645 void _bt_send_scan_result_event(const bt_remote_le_dev_info_t *le_dev_info,
1646 const bt_le_adv_info_t *adv_info)
1648 int result = BLUETOOTH_ERROR_NONE;
1650 GVariant *scan_data_param, *adv_data_param;
1652 bt_adapter_le_scanner_t *scanner = NULL;
1653 const char *adv_data = NULL;
1654 int adv_data_len = 0;
1655 const char *scan_data = NULL;
1656 int scan_data_len = 0;
1658 ret_if(le_dev_info == NULL);
1659 if (_bt_get_le_scan_type() == BT_LE_ACTIVE_SCAN)
1660 ret_if(adv_info == NULL);
1662 if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) {
1663 adv_data = le_dev_info->adv_data;
1664 adv_data_len = le_dev_info->adv_data_len;
1665 scan_data = le_dev_info->adv_data;
1668 adv_data = adv_info->data;
1669 adv_data_len = adv_info->data_len;
1670 scan_data = le_dev_info->adv_data;
1671 scan_data_len = le_dev_info->adv_data_len;
1674 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1676 if (scanner->is_scanning == FALSE)
1679 if (__bt_check_scan_result_with_filter(le_dev_info->address,
1680 adv_data, adv_data_len, scan_data, scan_data_len,
1684 adv_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1685 adv_data, adv_data_len, TRUE, NULL, NULL);
1686 scan_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1687 scan_data, scan_data_len, TRUE, NULL, NULL);
1689 param = g_variant_new("(isnnn@ayn@ay)",
1691 le_dev_info->address,
1692 le_dev_info->addr_type,
1699 _bt_send_event_to_dest(scanner->sender, BT_LE_ADAPTER_EVENT,
1700 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, param);
1704 int _bt_add_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
1707 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1708 GError *error = NULL;
1711 if (__bt_is_factory_test_mode()) {
1712 BT_ERR("Unable to add white list in factory binary !!");
1713 return BLUETOOTH_ERROR_NOT_SUPPORT;
1716 BT_CHECK_PARAMETER(device_address, return);
1718 if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
1719 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
1720 return BLUETOOTH_ERROR_INVALID_PARAM;
1722 _bt_convert_addr_type_to_string(address, device_address->addr);
1724 proxy = _bt_get_adapter_proxy();
1725 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1727 ret = g_dbus_proxy_call_sync(proxy, "AddDeviceWhiteList",
1728 g_variant_new("(su)", address, address_type),
1729 G_DBUS_CALL_FLAGS_NONE, -1,
1733 BT_ERR("AddDeviceWhiteList Fail: %s", error->message);
1734 g_clear_error(&error);
1735 return BLUETOOTH_ERROR_INTERNAL;
1739 g_variant_unref(ret);
1740 BT_INFO("Add white list");
1742 return BLUETOOTH_ERROR_NONE;
1745 int _bt_remove_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
1748 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1749 GError *error = NULL;
1752 if (__bt_is_factory_test_mode()) {
1753 BT_ERR("Unable to remove white list in factory binary !!");
1754 return BLUETOOTH_ERROR_NOT_SUPPORT;
1757 BT_CHECK_PARAMETER(device_address, return);
1759 if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
1760 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
1761 return BLUETOOTH_ERROR_INVALID_PARAM;
1763 _bt_convert_addr_type_to_string(address, device_address->addr);
1765 proxy = _bt_get_adapter_proxy();
1766 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1768 ret = g_dbus_proxy_call_sync(proxy, "RemoveDeviceWhiteList",
1769 g_variant_new("(su)", address, address_type),
1770 G_DBUS_CALL_FLAGS_NONE, -1,
1774 BT_ERR("RemoveDeviceWhiteList Fail: %s", error->message);
1775 g_clear_error(&error);
1776 return BLUETOOTH_ERROR_INTERNAL;
1780 g_variant_unref(ret);
1781 BT_INFO("Remove white list");
1783 return BLUETOOTH_ERROR_NONE;
1786 int _bt_clear_white_list(void)
1789 GError *error = NULL;
1792 if (__bt_is_factory_test_mode()) {
1793 BT_ERR("Unable to clear white list in factory binary !!");
1794 return BLUETOOTH_ERROR_NOT_SUPPORT;
1797 proxy = _bt_get_adapter_proxy();
1798 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1800 ret = g_dbus_proxy_call_sync(proxy, "ClearDeviceWhiteList",
1801 NULL,G_DBUS_CALL_FLAGS_NONE,
1805 BT_ERR("ClearDeviceWhiteList Fail: %s", error->message);
1806 g_clear_error(&error);
1807 return BLUETOOTH_ERROR_INTERNAL;
1810 g_variant_unref(ret);
1812 BT_INFO("Clear white list");
1814 return BLUETOOTH_ERROR_NONE;
1817 int _bt_le_read_maximum_data_length(
1818 bluetooth_le_read_maximum_data_length_t *max_le_datalength)
1820 GError *error = NULL;
1822 GVariant *reply = NULL;
1823 guint16 max_tx_octets, max_tx_time;
1824 guint16 max_rx_octets, max_rx_time;
1827 proxy = _bt_get_adapter_proxy();
1828 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1830 reply = g_dbus_proxy_call_sync(proxy, "LEReadMaximumDataLength",
1831 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1833 g_object_unref(proxy);
1835 if (reply == NULL) {
1836 BT_ERR("LEReadMaximumDataLength dBUS-RPC failed");
1837 if (error != NULL) {
1838 BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
1839 error->code, error->message);
1840 g_clear_error(&error);
1842 return BLUETOOTH_ERROR_INTERNAL;
1845 g_variant_get(reply ,"(qqqqi)", &max_tx_octets, &max_tx_time,
1846 &max_rx_octets, &max_rx_time, &err);
1848 g_variant_unref(reply);
1851 BT_DBG("error is : %d", err);
1852 return BLUETOOTH_ERROR_INTERNAL;
1855 max_le_datalength->max_tx_octets = max_tx_octets;
1856 max_le_datalength->max_tx_time = max_tx_time;
1857 max_le_datalength->max_rx_octets = max_rx_octets;
1858 max_le_datalength->max_rx_time = max_rx_time;
1860 return BLUETOOTH_ERROR_NONE;
1862 int _bt_le_write_host_suggested_default_data_length(
1863 const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
1865 GError *error = NULL;
1867 GVariant *reply = NULL;
1869 proxy = _bt_get_adapter_proxy();
1870 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1872 reply = g_dbus_proxy_call_sync(proxy,
1873 "LEWriteHostSuggestedDataLength",
1874 g_variant_new("(qq)", def_tx_Octets, def_tx_Time),
1875 G_DBUS_CALL_FLAGS_NONE,
1880 g_object_unref(proxy);
1882 if (reply == NULL) {
1883 BT_ERR("_bt_le_write_host_suggested_default_data_length dBUS-RPC failed");
1884 if (error != NULL) {
1885 BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
1886 error->code, error->message);
1887 g_clear_error(&error);
1889 return BLUETOOTH_ERROR_INTERNAL;
1892 g_variant_unref(reply);
1894 return BLUETOOTH_ERROR_NONE;
1897 int _bt_le_read_host_suggested_default_data_length(
1898 bluetooth_le_read_host_suggested_data_length_t *def_data_length)
1900 GError *error = NULL;
1902 GVariant *reply = NULL;
1903 guint16 def_tx_octets, def_tx_time;
1906 proxy = _bt_get_adapter_proxy();
1907 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1909 reply = g_dbus_proxy_call_sync(proxy, "LEReadHostSuggestedDataLength",
1910 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1912 if (reply == NULL) {
1913 BT_ERR("LEReadHostSuggestedDataLength dBUS-RPC failed");
1914 if (error != NULL) {
1915 BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
1916 error->code, error->message);
1917 g_clear_error(&error);
1919 return BLUETOOTH_ERROR_INTERNAL;
1922 g_variant_get(reply ,"(qqi)", &def_tx_octets, &def_tx_time, &err);
1924 g_variant_unref(reply);
1927 BT_DBG("error is : %d", err);
1928 return BLUETOOTH_ERROR_INTERNAL;
1931 def_data_length->def_tx_octets = def_tx_octets;
1932 def_data_length->def_tx_time = def_tx_time;
1934 return BLUETOOTH_ERROR_NONE;
1937 int _bt_le_set_data_length(bluetooth_device_address_t *device_address,
1938 const unsigned int max_tx_Octets, const unsigned int max_tx_Time)
1940 GError *error = NULL;
1941 guint16 txOctets = max_tx_Octets;
1942 guint16 txTime = max_tx_Time;
1943 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1944 gchar *device_path = NULL;
1945 GDBusConnection *conn;
1946 GDBusProxy *device_proxy;
1948 _bt_convert_addr_type_to_string(address, device_address->addr);
1950 device_path = _bt_get_device_object_path(address);
1952 BT_DBG("devic path is %s", device_path);
1954 if (device_path == NULL) {
1955 BT_DBG("Device path is null");
1956 return BLUETOOTH_ERROR_INTERNAL;
1959 conn = _bt_get_system_gconn();
1961 BT_ERR("conn == NULL");
1962 g_free(device_path);
1963 return BLUETOOTH_ERROR_INTERNAL;
1966 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1967 NULL, BT_BLUEZ_NAME,
1968 device_path, BT_DEVICE_INTERFACE, NULL, NULL);
1970 g_free(device_path);
1971 retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1973 g_dbus_proxy_call_sync(device_proxy,
1975 g_variant_new("(qq)", txOctets, txTime),
1976 G_DBUS_CALL_FLAGS_NONE,
1981 g_object_unref(device_proxy);
1984 BT_ERR("LESetDataLength error: [%s]", error->message);
1985 g_error_free(error);
1986 return BLUETOOTH_ERROR_INTERNAL;
1989 return BLUETOOTH_ERROR_NONE;