2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
24 #include <syspopup_caller.h>
26 #include "bt-internal-types.h"
27 #include "bt-service-common.h"
28 #include "bt-service-event.h"
29 #include "bt-service-adapter.h"
30 #include "bt-service-adapter-le.h"
31 #include "bt-service-util.h"
34 #define BT_ADV_INTERVAL_MIN 20 /* msec */
35 #define BT_ADV_INTERVAL_MAX 10240
36 #define BT_ADV_INTERVAL_SPLIT 0.625
37 #define BT_DEFAULT_ADV_MIN_INTERVAL 500
38 #define BT_DEFAULT_ADV_MAX_INTERVAL 500
39 #define BT_ADV_FILTER_POLICY_DEFAULT 0x00
40 #define BT_ADV_TYPE_DEFAULT 0x00
41 #define BT_ADV_FILTER_POLICY_ALLOW_SCAN_CONN_WL_ONLY 0x03
47 } bt_adapter_le_feature_info_t;
52 gboolean is_advertising;
54 } bt_adapter_le_adv_slot_t;
60 } bt_adapter_le_scanner_t;
62 static bluetooth_advertising_params_t adv_params = {
63 BT_DEFAULT_ADV_MIN_INTERVAL,
64 BT_DEFAULT_ADV_MAX_INTERVAL,
65 BT_ADV_FILTER_POLICY_DEFAULT,
67 static bluetooth_advertising_data_t adv_data = { {0} };
68 static int adv_data_len;
69 static bluetooth_scan_resp_data_t resp_data = { {0} };
70 static int resp_data_len;
72 static bt_adapter_le_feature_info_t le_feature_info = { 1, 0, 0 };
73 static bt_adapter_le_adv_slot_t *le_adv_slot = NULL;
75 GSList *scanner_list = NULL;
76 static gboolean is_le_set_scan_parameter = FALSE;
77 static gboolean is_le_scanning = FALSE;
78 static gboolean scan_filter_enabled = FALSE;
79 static bt_le_scan_type_t le_scan_type = BT_LE_PASSIVE_SCAN;
81 static void __bt_free_le_adv_slot(void)
85 if (le_adv_slot == NULL)
88 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
89 if (le_adv_slot[i].sender)
90 g_free(le_adv_slot[i].sender);
96 gboolean _bt_update_le_feature_support(const char *item, const char *value)
98 if (item == NULL || value == NULL)
102 _bt_service_adapter_le_init();
104 if (g_strcmp0(item, "adv_inst_max") == 0) {
107 slot_num = atoi(value);
108 retv_if(slot_num < 0, FALSE);
110 if (slot_num != le_feature_info.adv_inst_max) {
111 __bt_free_le_adv_slot();
112 le_feature_info.adv_inst_max = slot_num;
113 BT_INFO("Advertising instance max : %d", le_feature_info.adv_inst_max);
114 le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
116 } else if (g_strcmp0(item, "rpa_offloading") == 0) {
117 le_feature_info.rpa_offloading = atoi(value);
118 BT_INFO("RPA offloading : %d", le_feature_info.rpa_offloading);
119 } else if (g_strcmp0(item, "max_filter") == 0) {
120 le_feature_info.max_filter = atoi(value);
121 BT_INFO("BLE Scan max filter : %d", le_feature_info.max_filter);
123 BT_DBG("No registered item");
130 static gboolean __bt_is_factory_test_mode(void)
134 if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
135 BT_ERR("Get the DUT Mode fail");
140 BT_INFO("DUT Test Mode !!");
147 int __bt_get_available_adv_slot_id(const char *sender, int adv_handle, gboolean use_reserved_slot)
151 if (le_adv_slot == NULL) {
152 BT_ERR("le_adv_slot is NULL");
156 BT_DBG("adv_inst_max : %d", le_feature_info.adv_inst_max);
158 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
159 if (le_adv_slot[i].sender == NULL)
161 if ((g_strcmp0(le_adv_slot[i].sender, sender) == 0) && (le_adv_slot[i].adv_handle == adv_handle))
165 if (le_feature_info.adv_inst_max <= 2)
167 else if (le_feature_info.adv_inst_max > 2 && use_reserved_slot == TRUE)
172 for (; i < le_feature_info.adv_inst_max; i++) {
173 if (le_adv_slot[i].sender == NULL)
180 static void __bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id)
182 if (le_adv_slot == NULL)
185 if (le_adv_slot[slot_id].sender == NULL) {
186 le_adv_slot[slot_id].sender = strdup(sender);
187 le_adv_slot[slot_id].adv_handle = adv_handle;
191 void _bt_unregister_adv_slot_owner(int slot_id)
193 if (le_adv_slot == NULL)
196 if (le_adv_slot[slot_id].hold_timer_id > 0) {
197 BT_INFO("Hold state adv is not unregistered");
201 g_free(le_adv_slot[slot_id].sender);
202 le_adv_slot[slot_id].sender = NULL;
203 le_adv_slot[slot_id].adv_handle = 0;
206 const char* _bt_get_adv_slot_owner(int slot_id)
208 if (le_adv_slot == NULL)
211 return le_adv_slot[slot_id].sender;
214 int _bt_get_adv_slot_adv_handle(int slot_id)
216 if (le_adv_slot == NULL)
219 return le_adv_slot[slot_id].adv_handle;
222 void _bt_set_advertising_status(int slot_id, gboolean mode)
224 if (le_adv_slot == NULL)
227 le_adv_slot[slot_id].is_advertising = mode;
230 gboolean _bt_is_advertising(void)
232 gboolean status = FALSE;
235 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
236 if (le_adv_slot[i].is_advertising == TRUE)
243 gboolean _bt_is_multi_adv_supported(void)
245 return (le_feature_info.adv_inst_max > 1) ? TRUE : FALSE;
248 void _bt_stop_advertising_by_terminated_process(const char* terminated_name)
252 if (le_adv_slot == NULL)
255 for (i = 0; i < le_feature_info.adv_inst_max; i++) {
256 if (le_adv_slot[i].sender != NULL) {
257 if (strcasecmp(terminated_name, le_adv_slot[i].sender) == 0) {
258 BT_ERR("Stop advertising by terminated process(%s).", terminated_name);
259 _bt_set_advertising(terminated_name, le_adv_slot[i].adv_handle, FALSE, FALSE);
265 gboolean _bt_get_advertising_params(bluetooth_advertising_params_t *params)
270 memcpy(params, &adv_params, sizeof(bluetooth_advertising_params_t));
275 int _bt_set_advertising(const char *sender, int adv_handle, gboolean enable, gboolean use_reserved_slot)
278 GError *error = NULL;
282 if (__bt_is_factory_test_mode()) {
283 BT_ERR("Unable to start advertising in factory binary !!");
284 return BLUETOOTH_ERROR_NOT_SUPPORT;
287 if (_bt_adapter_get_status() != BT_ACTIVATED &&
288 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
289 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
292 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
294 BT_ERR("There is NO available slot!!");
295 return BLUETOOTH_ERROR_NO_RESOURCES;
298 if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
299 return BLUETOOTH_ERROR_IN_PROGRESS;
301 if (le_adv_slot[slot_id].hold_timer_id > 0) {
302 g_source_remove(le_adv_slot[slot_id].hold_timer_id);
303 le_adv_slot[slot_id].hold_timer_id = 0;
304 _bt_unregister_adv_slot_owner(slot_id);
307 if (le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
308 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
310 proxy = _bt_get_adapter_proxy();
311 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
313 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
314 g_variant_new("(bi)", enable, slot_id),
315 G_DBUS_CALL_FLAGS_NONE,
321 BT_ERR("SetAdvertising Fail: %s", error->message);
322 g_clear_error(&error);
323 return BLUETOOTH_ERROR_INTERNAL;
327 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
329 le_adv_slot[slot_id].is_advertising = enable;
330 BT_INFO_C("### Set advertising [%d]", enable);
333 g_variant_unref(ret);
335 return BLUETOOTH_ERROR_NONE;
338 int _bt_set_custom_advertising(const char *sender, int adv_handle,
339 gboolean enable, bluetooth_advertising_params_t *params, gboolean use_reserved_slot)
343 GError *error = NULL;
348 BT_CHECK_PARAMETER(params, return);
350 if (__bt_is_factory_test_mode()) {
351 BT_ERR("Unable to start advertising in factory binary !!");
352 return BLUETOOTH_ERROR_NOT_SUPPORT;
355 if (_bt_adapter_get_status() != BT_ACTIVATED &&
356 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
357 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
360 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
362 BT_ERR("There is NO available slot!!");
363 return BLUETOOTH_ERROR_NO_RESOURCES;
366 if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
367 return BLUETOOTH_ERROR_IN_PROGRESS;
369 if (le_adv_slot[slot_id].hold_timer_id > 0) {
370 g_source_remove(le_adv_slot[slot_id].hold_timer_id);
371 le_adv_slot[slot_id].hold_timer_id = 0;
372 _bt_unregister_adv_slot_owner(slot_id);
375 if (le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
376 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
378 proxy = _bt_get_adapter_proxy();
379 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
381 if (params->interval_min > params->interval_max ||
382 params->interval_min < BT_ADV_INTERVAL_MIN ||
383 params->interval_max > BT_ADV_INTERVAL_MAX)
384 return BLUETOOTH_ERROR_INVALID_PARAM;
386 if (params->filter_policy > BLUETOOTH_ALLOW_SCAN_CONN_WHITE_LIST)
387 return BLUETOOTH_ERROR_INVALID_PARAM;
389 if (params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_HIGH ||
390 params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_LOW ||
391 params->type == BLUETOOTH_ADV_NON_CONNECTABLE)
392 return BLUETOOTH_ERROR_NOT_SUPPORT;
394 min = params->interval_min / BT_ADV_INTERVAL_SPLIT;
395 max = params->interval_max / BT_ADV_INTERVAL_SPLIT;
397 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingParameters",
398 g_variant_new("(uuuui)", min, max,
399 params->filter_policy, params->type,
400 slot_id), G_DBUS_CALL_FLAGS_NONE,
404 BT_ERR("SetAdvertisingParameters Fail: %s", error->message);
405 g_clear_error(&error);
406 return BLUETOOTH_ERROR_INTERNAL;
409 adv_params.interval_min = params->interval_min;
410 adv_params.interval_max = params->interval_max;
411 adv_params.filter_policy = params->filter_policy;
412 adv_params.type = params->type;
415 g_variant_unref(ret);
417 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
418 g_variant_new("(bi)", enable, slot_id),
419 G_DBUS_CALL_FLAGS_NONE,
425 BT_ERR("SetAdvertising Fail: %s", error->message);
426 g_clear_error(&error);
427 return BLUETOOTH_ERROR_INTERNAL;
431 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
433 le_adv_slot[slot_id].is_advertising = enable;
434 BT_INFO_C("### Set advertising [%d]", enable);
436 g_variant_unref(ret);
438 return BLUETOOTH_ERROR_NONE;
441 static gboolean __bt_hold_current_advertising_timeout_cb(gpointer user_data)
444 GError *error = NULL;
447 BT_INFO("Restart advertising stopped by bt-service");
449 le_adv_slot[0].hold_timer_id = 0;
451 proxy = _bt_get_adapter_proxy();
452 retv_if(proxy == NULL, FALSE);
454 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
455 g_variant_new("(bi)", TRUE, 0),
456 G_DBUS_CALL_FLAGS_NONE,
462 BT_ERR("SetAdvertising Fail: %s", error->message);
463 g_clear_error(&error);
468 g_variant_unref(ret);
473 int _bt_hold_current_advertising(void)
476 GError *error = NULL;
479 if (le_adv_slot[0].sender && le_adv_slot[0].is_advertising == TRUE) {
480 BT_INFO("Stop current advertising by bt-service");
482 proxy = _bt_get_adapter_proxy();
483 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
485 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
486 g_variant_new("(bi)", FALSE, 0),
487 G_DBUS_CALL_FLAGS_NONE,
493 BT_ERR("SetAdvertising Fail: %s", error->message);
494 g_clear_error(&error);
495 return BLUETOOTH_ERROR_INTERNAL;
499 g_variant_unref(ret);
501 le_adv_slot[0].hold_timer_id = g_timeout_add(2000,
502 __bt_hold_current_advertising_timeout_cb, NULL);
504 BT_INFO("It's NOT advertising");
505 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
508 return BLUETOOTH_ERROR_NONE;
511 static int __bt_get_ad_data_by_type(char *in_data, int in_len,
512 char in_type, char **data, int *data_len)
514 if (in_data == NULL || data == NULL || data_len == NULL)
515 return BLUETOOTH_ERROR_INTERNAL;
518 return BLUETOOTH_ERROR_INTERNAL;
524 for (i = 0; i < in_len; i++) {
526 if (len <= 0 || i + 1 >= in_len) {
527 BT_ERR("Invalid advertising data");
528 return BLUETOOTH_ERROR_INTERNAL;
531 type = in_data[i + 1];
532 if (type == in_type) {
542 if (i + len > in_len) {
543 BT_ERR("Invalid advertising data");
544 return BLUETOOTH_ERROR_INTERNAL;
545 } else if (len == 0) {
546 BT_DBG("AD Type 0x%02x data is not set", in_type);
549 return BLUETOOTH_ERROR_NONE;
552 *data = g_memdup(&in_data[i], len);
554 return BLUETOOTH_ERROR_OUT_OF_MEMORY;
557 return BLUETOOTH_ERROR_NONE;
560 int _bt_get_advertising_data(bluetooth_advertising_data_t *adv, int *length)
562 BT_CHECK_PARAMETER(adv, return);
563 BT_CHECK_PARAMETER(length, return);
565 memcpy(adv, &adv_data, sizeof(adv_data));
566 *length = adv_data_len;
568 return BLUETOOTH_ERROR_NONE;
571 int _bt_set_advertising_data(const char *sender, int adv_handle,
572 bluetooth_advertising_data_t *adv, int length, gboolean use_reserved_slot)
575 GError *error = NULL;
576 GVariant *ret, *ad_data, *param = NULL;
577 GVariant *temp = NULL;
578 GVariantBuilder *builder;
580 char *old_mdata = NULL;
581 char *new_mdata = NULL;
586 if (__bt_is_factory_test_mode()) {
587 BT_ERR("Unable to set advertising data in factory binary !!");
588 return BLUETOOTH_ERROR_NOT_SUPPORT;
591 BT_CHECK_PARAMETER(adv, return);
593 if (_bt_adapter_get_status() != BT_ACTIVATED &&
594 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
595 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
598 proxy = _bt_get_adapter_proxy();
599 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
601 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
603 BT_ERR("There is NO available slot!!");
604 return BLUETOOTH_ERROR_NO_RESOURCES;
607 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
608 for (i = 0; i < length; i++)
609 g_variant_builder_add(builder, "y", adv->data[i]);
611 temp = g_variant_new("ay", builder);
612 g_variant_builder_unref(builder);
613 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingData",
614 g_variant_new("(@ayi)", temp, slot_id),
615 G_DBUS_CALL_FLAGS_NONE,
619 BT_ERR("SetAdvertisingData Fail: %s", error->message);
620 g_clear_error(&error);
621 return BLUETOOTH_ERROR_INTERNAL;
624 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
626 __bt_get_ad_data_by_type((char *)adv_data.data, adv_data_len, 0xff,
627 &old_mdata, &old_len);
628 __bt_get_ad_data_by_type((char *)adv->data, length, 0xff,
629 &new_mdata, &new_len);
630 if (old_len != new_len ||
631 (old_mdata && new_mdata &&
632 memcmp(old_mdata, new_mdata, new_len))) {
633 ad_data = g_variant_new_from_data((const GVariantType *)"ay",
634 new_mdata, new_len, TRUE, NULL, NULL);
635 param = g_variant_new("(@ay)", ad_data);
636 _bt_send_event(BT_ADAPTER_EVENT,
637 BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
643 memset(&adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
644 memcpy(&adv_data, adv, length);
645 adv_data_len = length;
647 BT_INFO("Set advertising data");
649 g_variant_unref(ret);
651 return BLUETOOTH_ERROR_NONE;
654 int _bt_get_scan_response_data(bluetooth_scan_resp_data_t *response, int *length)
656 BT_CHECK_PARAMETER(response, return);
657 BT_CHECK_PARAMETER(length, return);
659 memcpy(response, &resp_data, sizeof(resp_data));
660 *length = resp_data_len;
662 return BLUETOOTH_ERROR_NONE;
665 int _bt_set_scan_response_data(const char *sender, int adv_handle,
666 bluetooth_scan_resp_data_t *response, int length, gboolean use_reserved_slot)
669 GError *error = NULL;
670 GVariant *ret, *scan_data, *param = NULL;
671 GVariant *temp = NULL;
672 GVariantBuilder *builder;
674 char *old_mdata = NULL;
675 char *new_mdata = NULL;
680 if (__bt_is_factory_test_mode()) {
681 BT_ERR("Unable to set scan response list in factory binary !!");
682 return BLUETOOTH_ERROR_NOT_SUPPORT;
685 BT_CHECK_PARAMETER(response, return);
687 if (_bt_adapter_get_status() != BT_ACTIVATED &&
688 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
689 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
692 proxy = _bt_get_adapter_proxy();
693 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
695 slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
697 BT_ERR("There is NO available slot!!");
698 return BLUETOOTH_ERROR_NO_RESOURCES;
700 builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
701 for (i = 0; i < length; i++)
702 g_variant_builder_add(builder, "y", response->data[i]);
704 temp = g_variant_new("ay", builder);
705 g_variant_builder_unref(builder);
706 ret = g_dbus_proxy_call_sync(proxy, "SetScanRespData",
707 g_variant_new("(@ayi)", temp, slot_id),
708 G_DBUS_CALL_FLAGS_NONE,
712 BT_ERR("SetScanRespData Fail: %s", error->message);
713 g_clear_error(&error);
714 return BLUETOOTH_ERROR_INTERNAL;
717 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
719 /* Compare with previous scan resp data */
720 __bt_get_ad_data_by_type((char *)resp_data.data, resp_data_len, 0xff,
721 &old_mdata, &old_len);
722 __bt_get_ad_data_by_type((char *)response->data, length, 0xff,
723 &new_mdata, &new_len);
724 if (old_len != new_len ||
725 (old_mdata && new_mdata &&
726 memcmp(old_mdata, new_mdata, new_len))) {
727 scan_data = g_variant_new_from_data((const GVariantType *)"ay",
728 new_mdata, new_len, TRUE, NULL, NULL);
729 param = g_variant_new("(@ay)", scan_data);
730 _bt_send_event(BT_ADAPTER_EVENT,
731 BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
737 memset(&resp_data, 0x00, sizeof(bluetooth_scan_resp_data_t));
738 memcpy(&resp_data, response, length);
739 resp_data_len = length;
742 g_variant_unref(ret);
743 BT_INFO("Set scan response data");
744 return BLUETOOTH_ERROR_NONE;
747 int _bt_set_scan_parameters(bluetooth_le_scan_params_t *params)
750 GError *error = NULL;
755 BT_CHECK_PARAMETER(params, return);
757 if (_bt_adapter_get_status() != BT_ACTIVATED &&
758 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
759 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
762 proxy = _bt_get_adapter_proxy();
763 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
765 if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
766 return BLUETOOTH_ERROR_INVALID_PARAM;
768 if (params->window < BT_LE_SCAN_WINDOW_MIN || params->window > BT_LE_SCAN_WINDOW_MAX)
769 return BLUETOOTH_ERROR_INVALID_PARAM;
771 if (params->window > params->interval)
772 return BLUETOOTH_ERROR_INVALID_PARAM;
774 itv = params->interval / BT_ADV_INTERVAL_SPLIT;
775 win = params->window / BT_ADV_INTERVAL_SPLIT;
777 ret = g_dbus_proxy_call_sync(proxy, "SetScanParameters",
778 g_variant_new("(uuu)", params->type, itv, win),
779 G_DBUS_CALL_FLAGS_NONE, -1,
783 BT_ERR("SetScanParameters Fail: %s", error->message);
784 g_clear_error(&error);
785 return BLUETOOTH_ERROR_INTERNAL;
788 _bt_set_le_scan_type(params->type);
790 is_le_set_scan_parameter = TRUE;
793 g_variant_unref(ret);
794 BT_INFO("Set scan parameters");
795 return BLUETOOTH_ERROR_NONE;
798 bt_adapter_le_scanner_t* __bt_find_scanner_from_list(const char *sender)
801 bt_adapter_le_scanner_t *scanner;
803 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
805 if (g_strcmp0(scanner->sender, sender) == 0)
812 int __bt_get_available_scan_filter_slot_id(void)
815 bt_adapter_le_scanner_t *scanner;
817 bluetooth_le_scan_filter_t *filter_data;
818 gboolean *slot_check_list = NULL;
821 if (le_feature_info.max_filter == 0) {
822 BT_ERR("Scan filter is NOT Supported");
825 slot_check_list = g_malloc0(sizeof(gboolean) * le_feature_info.max_filter);
827 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
829 for (fl = scanner->filter_list; fl != NULL; fl = g_slist_next(fl)) {
830 filter_data = fl->data;
831 if (filter_data->slot_id < le_feature_info.max_filter)
832 slot_check_list[filter_data->slot_id] = TRUE;
836 for (i = 0; i < le_feature_info.max_filter; i++) {
837 if (slot_check_list[i] == FALSE) {
838 g_free(slot_check_list);
843 BT_ERR("There is NO available slot for scan filter.");
844 g_free(slot_check_list);
848 gboolean _bt_is_scan_filter_supported(void)
850 if (le_feature_info.max_filter > 0)
856 int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id)
859 GError *error = NULL;
860 GVariant *ret, *param;
861 GVariant *arr_uuid_param = NULL, *arr_uuid_mask_param = NULL;
862 GVariant *arr_data_param = NULL, *arr_data_mask_param = NULL;
863 GArray *arr_uuid = NULL;
864 GArray *arr_uuid_mask = NULL;
865 GArray *arr_data = NULL;
866 GArray *arr_data_mask = NULL;
867 bt_adapter_le_scanner_t *scanner = NULL;
868 bluetooth_le_scan_filter_t *filter_data = NULL;
869 int feature_selection = 0;
871 *slot_id = __bt_get_available_scan_filter_slot_id();
873 return BLUETOOTH_ERROR_NO_RESOURCES;
875 proxy = _bt_get_adapter_proxy();
876 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
878 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
879 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
880 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
882 _bt_convert_addr_type_to_string(address, filter->device_address.addr);
884 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
885 NULL, 0, TRUE, NULL, NULL);
886 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
887 NULL, 0, TRUE, NULL, NULL);
888 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
889 NULL, 0, TRUE, NULL, NULL);
890 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
891 NULL, 0, TRUE, NULL, NULL);
893 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
895 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
896 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS, // filter_type
897 *slot_id, // filter_index
899 0, // company_id_mask
900 arr_uuid_param, // p_uuid
901 arr_uuid_mask_param, // p_uuid_mask
904 arr_data_param, // p_data
905 arr_data_mask_param); // p_mask
907 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
908 param, G_DBUS_CALL_FLAGS_NONE,
912 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
913 g_clear_error(&error);
916 g_variant_unref(ret);
919 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
920 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME;
922 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
923 NULL, 0, TRUE, NULL, NULL);
924 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
925 NULL, 0, TRUE, NULL, NULL);
926 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
927 NULL, 0, TRUE, NULL, NULL);
928 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
929 NULL, 0, TRUE, NULL, NULL);
931 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
933 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
934 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME, // filter_type
935 *slot_id, // filter_index
937 0, // company_id_mask
938 arr_uuid_param, // p_uuid
939 arr_uuid_mask_param, // p_uuid_mask
940 filter->device_name, // string
942 arr_data_param, // p_data
943 arr_data_mask_param);
945 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
946 param, G_DBUS_CALL_FLAGS_NONE,
950 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
951 g_clear_error(&error);
954 g_variant_unref(ret);
957 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
958 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID;
960 arr_uuid = g_array_new(TRUE, TRUE, sizeof(guint8));
961 arr_uuid_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
963 g_array_append_vals(arr_uuid, filter->service_uuid.data.data, filter->service_uuid.data_len * sizeof(guint8));
964 g_array_append_vals(arr_uuid_mask, filter->service_uuid_mask.data.data, filter->service_uuid_mask.data_len * sizeof(guint8));
966 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
967 arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
968 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
969 arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
970 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
971 NULL, 0, TRUE, NULL, NULL);
972 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
973 NULL, 0, TRUE, NULL, NULL);
975 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
977 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
978 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID, // filter_type
979 *slot_id, // filter_index
981 0, // company_id_mask
982 arr_uuid_param, // p_uuid
983 arr_uuid_mask_param, // p_uuid_mask
986 arr_data_param, // p_data
987 arr_data_mask_param);
989 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
990 param, G_DBUS_CALL_FLAGS_NONE,
994 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
995 g_clear_error(&error);
998 g_variant_unref(ret);
1000 g_array_free(arr_uuid, TRUE);
1001 g_array_free(arr_uuid_mask, TRUE);
1002 g_array_free(arr_data, TRUE);
1003 g_array_free(arr_data_mask, TRUE);
1006 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
1007 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
1009 arr_uuid = g_array_new(TRUE, TRUE, sizeof(guint8));
1010 arr_uuid_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1012 g_array_append_vals(arr_uuid, filter->service_solicitation_uuid.data.data, filter->service_solicitation_uuid.data_len * sizeof(guint8));
1013 g_array_append_vals(arr_uuid_mask, filter->service_solicitation_uuid_mask.data.data, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8));
1015 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1016 arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
1017 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1018 arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
1019 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1020 NULL, 0, TRUE, NULL, NULL);
1021 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1022 NULL, 0, TRUE, NULL, NULL);
1024 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1026 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1027 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID, // filter_type
1028 *slot_id, // filter_index
1030 0, // company_id_mask
1031 arr_uuid_param, // p_uuid
1032 arr_uuid_mask_param, // p_uuid_mask
1035 arr_data_param, // p_data
1036 arr_data_mask_param);
1038 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
1039 G_DBUS_CALL_FLAGS_NONE,
1043 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1044 g_clear_error(&error);
1047 g_variant_unref(ret);
1049 g_array_free(arr_uuid, TRUE);
1050 g_array_free(arr_uuid_mask, TRUE);
1053 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
1054 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
1056 arr_data = g_array_new(TRUE, TRUE, sizeof(guint8));
1057 arr_data_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1059 g_array_append_vals(arr_data, filter->service_data.data.data, filter->service_data.data_len * sizeof(guint8));
1060 g_array_append_vals(arr_data_mask, filter->service_data_mask.data.data, filter->service_data_mask.data_len * sizeof(guint8));
1062 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1063 NULL, 0, TRUE, NULL, NULL);
1064 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1065 NULL, 0, TRUE, NULL, NULL);
1066 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1067 arr_data->data, arr_data->len, TRUE, NULL, NULL);
1068 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1069 arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
1071 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1073 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1074 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA, // filter_type
1075 *slot_id, // filter_index
1077 0, // company_id_mask
1078 arr_uuid_param, // p_uuid
1079 arr_uuid_mask_param, // p_uuid_mask
1082 arr_data_param, // p_data
1083 arr_data_mask_param);
1085 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
1086 G_DBUS_CALL_FLAGS_NONE,
1090 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1091 g_clear_error(&error);
1094 g_variant_unref(ret);
1096 g_array_free(arr_data, TRUE);
1097 g_array_free(arr_data_mask, TRUE);
1100 if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
1101 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
1103 arr_data = g_array_new(TRUE, TRUE, sizeof(guint8));
1104 arr_data_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1106 g_array_append_vals(arr_data, filter->manufacturer_data.data.data, filter->manufacturer_data.data_len * sizeof(guint8));
1107 g_array_append_vals(arr_data_mask, filter->manufacturer_data_mask.data.data, filter->manufacturer_data_mask.data_len * sizeof(guint8));
1109 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1110 NULL, 0, TRUE, NULL, NULL);
1111 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1112 NULL, 0, TRUE, NULL, NULL);
1113 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1114 arr_data->data, arr_data->len, TRUE, NULL, NULL);
1115 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1116 arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
1118 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1120 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1121 BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA, // filter_type
1122 *slot_id, // filter_index
1123 filter->manufacturer_id, // company_id
1124 0xFFFF, // company_id_mask
1125 arr_uuid_param, // p_uuid
1126 arr_uuid_mask_param, // p_uuid_mask
1129 arr_data_param, // p_data
1130 arr_data_mask_param);
1132 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
1133 G_DBUS_CALL_FLAGS_NONE,
1137 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1138 g_clear_error(&error);
1141 g_variant_unref(ret);
1143 g_array_free(arr_data, TRUE);
1144 g_array_free(arr_data_mask, TRUE);
1147 BT_DBG("Filter selection %.2x", feature_selection);
1149 param = g_variant_new("(iiiiiiiiiiii)",
1151 0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1152 *slot_id, // filter_index
1153 feature_selection, // feat_seln
1154 0, // list_logic_type (OR - 0x00, AND - 0x01)
1155 1, // filt_logic_type (OR - 0x00, AND - 0x01)
1156 -127, // rssi_high_thres
1157 -127, // rssi_low_thres
1158 0, // dely_mode (Immediate - 0x00, on found - 0x01, batched - 0x02)
1161 0); // found_timeout_cnt
1162 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_param_setup",
1163 param, G_DBUS_CALL_FLAGS_NONE,
1167 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1168 g_clear_error(&error);
1171 scanner = __bt_find_scanner_from_list(sender);
1172 if (scanner == NULL) {
1173 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1174 scanner->sender = g_strdup(sender);
1175 scanner_list = g_slist_append(scanner_list, scanner);
1180 filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
1181 memcpy(filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
1182 filter_data->slot_id = *slot_id;
1184 scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
1188 g_variant_unref(ret);
1189 return BLUETOOTH_ERROR_NONE;
1192 int _bt_unregister_scan_filter(const char *sender, int slot_id)
1195 GError *error = NULL;
1197 bt_adapter_le_scanner_t *scanner = NULL;
1198 bluetooth_le_scan_filter_t *filter_data = NULL;
1200 gboolean is_slot_id_found = FALSE;
1202 scanner = __bt_find_scanner_from_list(sender);
1203 if (scanner == NULL) {
1204 BT_ERR("There is NO available scanner.");
1205 return BLUETOOTH_ERROR_NOT_FOUND;
1208 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1209 filter_data = l->data;
1210 if (filter_data->slot_id == slot_id) {
1211 is_slot_id_found = TRUE;
1215 if (is_slot_id_found == FALSE) {
1216 BT_ERR("There is NO registered slot.");
1217 return BLUETOOTH_ERROR_NOT_FOUND;
1220 proxy = _bt_get_adapter_proxy();
1221 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1223 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1224 g_variant_new("(ii)", 0, slot_id),
1225 G_DBUS_CALL_FLAGS_NONE,
1229 BT_ERR("scan_filter_clear Fail: %s", error->message);
1230 g_clear_error(&error);
1233 scanner->filter_list = g_slist_remove(scanner->filter_list, filter_data);
1234 g_free(filter_data);
1237 g_variant_unref(ret);
1238 return BLUETOOTH_ERROR_NONE;
1241 int _bt_unregister_all_scan_filters(const char *sender)
1244 GError *error = NULL;
1246 bt_adapter_le_scanner_t *scanner = NULL;
1247 bluetooth_le_scan_filter_t *filter_data = NULL;
1250 scanner = __bt_find_scanner_from_list(sender);
1251 if (scanner == NULL) {
1252 BT_ERR("There is NO available scanner.");
1253 return BLUETOOTH_ERROR_NOT_FOUND;
1256 proxy = _bt_get_adapter_proxy();
1257 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1259 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1260 filter_data = l->data;
1262 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1263 g_variant_new("(ii)", 0, filter_data->slot_id),
1264 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1267 BT_ERR("scan_filter_clear Fail: %s", error->message);
1268 g_clear_error(&error);
1271 g_variant_unref(ret);
1274 g_slist_free_full(scanner->filter_list, g_free);
1275 scanner->filter_list = NULL;
1277 return BLUETOOTH_ERROR_NONE;
1280 int _bt_start_le_scan(const char *sender)
1283 GError *error = NULL;
1285 bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1287 if (scanner == NULL) {
1288 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1289 scanner->sender = g_strdup(sender);
1290 scanner_list = g_slist_append(scanner_list, scanner);
1293 if (scanner->is_scanning == TRUE) {
1294 BT_ERR("BT is already in LE scanning");
1295 return BLUETOOTH_ERROR_IN_PROGRESS;
1297 scanner->is_scanning = TRUE;
1299 proxy = _bt_get_adapter_proxy();
1300 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1302 if (_bt_is_le_scanning()) {
1303 if (scan_filter_enabled == TRUE) {
1304 if (scanner->filter_list == NULL) {
1305 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1306 g_variant_new("(ib)", 0, FALSE),
1307 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1310 BT_ERR("scan_filter_clear Fail: %s", error->message);
1311 g_clear_error(&error);
1315 g_variant_unref(ret);
1316 BT_INFO("Disable LE Scan Filter");
1317 scan_filter_enabled = FALSE;
1319 BT_INFO("LE Filter Scan is continue");
1322 BT_INFO("LE Full Scan is already on progress");
1324 return BLUETOOTH_ERROR_NONE;
1326 if (is_le_set_scan_parameter == FALSE) {
1327 /* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
1328 bluetooth_le_scan_params_t scan_params;
1329 scan_params.type = BT_LE_ACTIVE_SCAN;
1330 scan_params.interval = 5000;
1331 scan_params.window = 500;
1332 _bt_set_scan_parameters(&scan_params);
1335 if (scanner->filter_list == NULL) {
1336 BT_INFO("Start LE Full Scan");
1337 scan_filter_enabled = FALSE;
1339 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1340 g_variant_new("(ib)", 0, TRUE),
1341 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1344 BT_ERR("scan_filter_clear Fail: %s", error->message);
1345 g_clear_error(&error);
1349 g_variant_unref(ret);
1350 BT_INFO("Enable LE Scan Filter");
1351 scan_filter_enabled = TRUE;
1355 ret = g_dbus_proxy_call_sync(proxy, "StartLEDiscovery",
1356 NULL, G_DBUS_CALL_FLAGS_NONE,
1360 BT_ERR("StartLEDiscovery Fail: %s", error->message);
1361 g_clear_error(&error);
1362 return BLUETOOTH_ERROR_INTERNAL;
1366 g_variant_unref(ret);
1367 return BLUETOOTH_ERROR_NONE;
1370 int _bt_stop_le_scan(const char *sender)
1373 GError *error = NULL;
1375 bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1377 gboolean next_scanning = FALSE;
1378 gboolean need_scan_filter = TRUE;
1380 if (scanner == NULL || scanner->is_scanning == FALSE)
1381 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1383 scanner->is_scanning = FALSE;
1385 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1387 if (scanner->is_scanning == TRUE) {
1388 next_scanning = TRUE;
1389 if (scanner->filter_list == NULL)
1390 need_scan_filter = FALSE;
1394 proxy = _bt_get_adapter_proxy();
1395 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1397 if (next_scanning == TRUE) {
1398 if (scan_filter_enabled == FALSE && need_scan_filter == TRUE) {
1399 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1400 g_variant_new("(ib)", 0, TRUE),
1401 G_DBUS_CALL_FLAGS_NONE,
1405 BT_ERR("scan_filter_clear Fail: %s", error->message);
1406 g_clear_error(&error);
1410 g_variant_unref(ret);
1411 BT_INFO("Enable LE Scan Filter");
1412 scan_filter_enabled = TRUE;
1414 return BLUETOOTH_ERROR_NONE;
1416 if (scan_filter_enabled == TRUE) {
1417 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1418 g_variant_new("(ib)", 0, FALSE),
1419 G_DBUS_CALL_FLAGS_NONE,
1423 BT_ERR("scan_filter_clear Fail: %s", error->message);
1424 g_clear_error(&error);
1428 g_variant_unref(ret);
1429 BT_INFO("Disable LE Scan Filter");
1431 BT_INFO("Just stop LE scan");
1435 ret = g_dbus_proxy_call_sync(proxy, "StopLEDiscovery",
1436 NULL, G_DBUS_CALL_FLAGS_NONE,
1439 BT_ERR("LE Scan stop failed");
1440 return BLUETOOTH_ERROR_INTERNAL;
1443 scan_filter_enabled = FALSE;
1444 is_le_set_scan_parameter = FALSE;
1446 g_variant_unref(ret);
1447 return BLUETOOTH_ERROR_NONE;
1450 void _bt_disable_all_scanner_status(void)
1453 bt_adapter_le_scanner_t *scanner;
1455 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1457 scanner->is_scanning = FALSE;
1461 static void __bt_free_le_scanner(void)
1464 bt_adapter_le_scanner_t *scanner;
1466 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1468 g_free(scanner->sender);
1469 g_slist_free_full(scanner->filter_list, g_free);
1473 g_slist_free(scanner_list);
1474 scanner_list = NULL;
1476 scan_filter_enabled = FALSE;
1477 is_le_scanning = FALSE;
1478 is_le_set_scan_parameter = FALSE;
1481 void _bt_set_le_scan_status(gboolean mode)
1483 is_le_scanning = mode;
1486 gboolean _bt_is_le_scanning(void)
1488 return is_le_scanning;
1491 void _bt_set_le_scan_type(bt_le_scan_type_t type)
1493 le_scan_type = type;
1496 bt_le_scan_type_t _bt_get_le_scan_type(void)
1498 return le_scan_type;
1501 static gboolean __bt_check_scan_result_uuid(const char *adv_data,
1502 int adv_data_len, const char *svc_uuid, int uuid_len,
1503 const char *uuid_mask, char ad_type)
1509 __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1510 ad_type, &data, &data_len);
1512 for (i = 0; i < data_len; i += uuid_len) {
1513 if (uuid_len > (data_len - i))
1516 if (_bt_byte_arr_cmp_with_mask(data + i,
1517 svc_uuid, uuid_mask, uuid_len) == 0) {
1528 static gboolean __bt_check_scan_result_with_filter(const char *device_address,
1529 const char *adv_data, int adv_data_len,
1530 const char *scan_data, int scan_data_len,
1531 const bt_adapter_le_scanner_t *scanner)
1534 bluetooth_le_scan_filter_t *filter_data = NULL;
1537 gboolean is_matched = FALSE;
1539 if (scanner->filter_list == NULL) {
1540 BT_INFO("This scanner is on Full Scan.");
1544 for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1545 filter_data = l->data;
1547 if (filter_data->added_features &
1548 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
1549 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1551 _bt_convert_addr_type_to_string(address,
1552 filter_data->device_address.addr);
1553 if (strncmp(address, device_address,
1554 BT_ADDRESS_STRING_SIZE) != 0)
1558 if (filter_data->added_features &
1559 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
1562 if (__bt_check_scan_result_uuid(adv_data,
1564 (char*)filter_data->service_uuid.data.data,
1565 filter_data->service_uuid.data_len,
1566 (char*)filter_data->service_uuid_mask.data.data,
1567 BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1570 if (__bt_check_scan_result_uuid(adv_data,
1572 (char*)filter_data->service_uuid.data.data,
1573 filter_data->service_uuid.data_len,
1574 (char*)filter_data->service_uuid_mask.data.data,
1575 BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1578 if (__bt_check_scan_result_uuid(adv_data,
1580 (char*)filter_data->service_uuid.data.data,
1581 filter_data->service_uuid.data_len,
1582 (char*)filter_data->service_uuid_mask.data.data,
1583 BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1586 if (__bt_check_scan_result_uuid(adv_data,
1588 (char*)filter_data->service_uuid.data.data,
1589 filter_data->service_uuid.data_len,
1590 (char*)filter_data->service_uuid_mask.data.data,
1591 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1594 if (__bt_check_scan_result_uuid(scan_data,
1596 (char*)filter_data->service_uuid.data.data,
1597 filter_data->service_uuid.data_len,
1598 (char*)filter_data->service_uuid_mask.data.data,
1599 BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1602 if (__bt_check_scan_result_uuid(scan_data,
1604 (char*)filter_data->service_uuid.data.data,
1605 filter_data->service_uuid.data_len,
1606 (char*)filter_data->service_uuid_mask.data.data,
1607 BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1610 if (__bt_check_scan_result_uuid(scan_data,
1612 (char*)filter_data->service_uuid.data.data,
1613 filter_data->service_uuid.data_len,
1614 (char*)filter_data->service_uuid_mask.data.data,
1615 BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1618 if (__bt_check_scan_result_uuid(scan_data,
1620 (char*)filter_data->service_uuid.data.data,
1621 filter_data->service_uuid.data_len,
1622 (char*)filter_data->service_uuid_mask.data.data,
1623 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1627 if (is_matched == FALSE)
1630 if (filter_data->added_features &
1631 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
1634 if (__bt_check_scan_result_uuid(adv_data,
1636 (char*)filter_data->service_solicitation_uuid.data.data,
1637 filter_data->service_solicitation_uuid.data_len,
1638 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1639 BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS)
1642 if (__bt_check_scan_result_uuid(adv_data,
1644 (char*)filter_data->service_solicitation_uuid.data.data,
1645 filter_data->service_solicitation_uuid.data_len,
1646 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1647 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1650 if (__bt_check_scan_result_uuid(scan_data,
1652 (char*)filter_data->service_solicitation_uuid.data.data,
1653 filter_data->service_solicitation_uuid.data_len,
1654 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1655 BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS)
1658 if (__bt_check_scan_result_uuid(scan_data,
1660 (char*)filter_data->service_solicitation_uuid.data.data,
1661 filter_data->service_solicitation_uuid.data_len,
1662 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1663 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1667 if (is_matched == FALSE)
1670 if (filter_data->added_features &
1671 BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
1672 char name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX] = {0, };
1677 __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1678 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1681 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1682 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1683 memcpy(name, data, data_len);
1684 name[data_len] = '\0';
1687 if (strncmp(filter_data->device_name,
1688 name, data_len) == 0)
1691 __bt_get_ad_data_by_type((char*)scan_data,
1693 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1696 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1697 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1698 memcpy(name, data, data_len);
1699 name[data_len] = '\0';
1702 if (strncmp(filter_data->device_name,
1703 name, data_len) == 0)
1707 if (is_matched == FALSE)
1710 if (filter_data->added_features &
1711 BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
1716 __bt_get_ad_data_by_type((char*)adv_data,
1718 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1722 int manufacturer_id;
1723 manufacturer_id = (data[1] << 8) + data[0];
1725 if (filter_data->manufacturer_id == manufacturer_id) {
1726 if (filter_data->manufacturer_data.data_len == 0) {
1729 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1730 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1731 if (_bt_byte_arr_cmp_with_mask(data + 2,
1732 (char*)filter_data->manufacturer_data.data.data,
1733 (char*)filter_data->manufacturer_data_mask.data.data,
1734 data_len - 2) == 0) {
1742 __bt_get_ad_data_by_type((char*)scan_data,
1744 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1748 int manufacturer_id;
1749 manufacturer_id = (data[1] << 8) + data[0];
1751 if (filter_data->manufacturer_id == manufacturer_id) {
1752 if (filter_data->manufacturer_data.data_len == 0) {
1755 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1756 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1757 if (_bt_byte_arr_cmp_with_mask(data + 2,
1758 (char*)filter_data->manufacturer_data.data.data,
1759 (char*)filter_data->manufacturer_data_mask.data.data,
1760 data_len - 2) == 0) {
1769 if (is_matched == FALSE)
1772 if (filter_data->added_features &
1773 BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
1778 __bt_get_ad_data_by_type((char*)adv_data,
1780 BT_LE_AD_TYPE_SERVICE_DATA,
1783 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1784 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1785 if (_bt_byte_arr_cmp_with_mask(data,
1786 (char*)filter_data->service_data.data.data,
1787 (char*)filter_data->service_data_mask.data.data,
1794 __bt_get_ad_data_by_type((char*)scan_data,
1796 BT_LE_AD_TYPE_SERVICE_DATA,
1799 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1800 data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1801 if (_bt_byte_arr_cmp_with_mask(data,
1802 (char*)filter_data->service_data.data.data,
1803 (char*)filter_data->service_data_mask.data.data,
1811 if (is_matched == FALSE)
1815 BT_INFO("The scan result is conformable.");
1819 BT_INFO("The scan result is NOT conformable.");
1823 void _bt_send_scan_result_event(const bt_remote_le_dev_info_t *le_dev_info,
1824 const bt_le_adv_info_t *adv_info)
1826 int result = BLUETOOTH_ERROR_NONE;
1828 GVariant *scan_data_param, *adv_data_param;
1830 bt_adapter_le_scanner_t *scanner = NULL;
1831 const char *adv_data = NULL;
1832 int adv_data_len = 0;
1833 const char *scan_data = NULL;
1834 int scan_data_len = 0;
1836 ret_if(le_dev_info == NULL);
1837 if (_bt_get_le_scan_type() == BT_LE_ACTIVE_SCAN)
1838 ret_if(adv_info == NULL);
1840 if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) {
1841 adv_data = le_dev_info->adv_data;
1842 adv_data_len = le_dev_info->adv_data_len;
1843 scan_data = le_dev_info->adv_data;
1846 adv_data = adv_info->data;
1847 adv_data_len = adv_info->data_len;
1848 scan_data = le_dev_info->adv_data;
1849 scan_data_len = le_dev_info->adv_data_len;
1852 for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1854 if (scanner->is_scanning == FALSE)
1857 if (__bt_check_scan_result_with_filter(le_dev_info->address,
1858 adv_data, adv_data_len, scan_data, scan_data_len,
1862 adv_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1863 adv_data, adv_data_len, TRUE, NULL, NULL);
1864 scan_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1865 scan_data, scan_data_len, TRUE, NULL, NULL);
1867 param = g_variant_new("(isnnn@ayn@ay)",
1869 le_dev_info->address,
1870 le_dev_info->addr_type,
1877 _bt_send_event_to_dest(scanner->sender, BT_LE_ADAPTER_EVENT,
1878 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, param);
1882 int _bt_add_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
1885 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1886 GError *error = NULL;
1889 if (__bt_is_factory_test_mode()) {
1890 BT_ERR("Unable to add white list in factory binary !!");
1891 return BLUETOOTH_ERROR_NOT_SUPPORT;
1894 BT_CHECK_PARAMETER(device_address, return);
1896 if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
1897 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
1898 return BLUETOOTH_ERROR_INVALID_PARAM;
1900 _bt_convert_addr_type_to_string(address, device_address->addr);
1902 proxy = _bt_get_adapter_proxy();
1903 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1905 ret = g_dbus_proxy_call_sync(proxy, "AddDeviceWhiteList",
1906 g_variant_new("(su)", address, address_type),
1907 G_DBUS_CALL_FLAGS_NONE, -1,
1911 BT_ERR("AddDeviceWhiteList Fail: %s", error->message);
1912 g_clear_error(&error);
1913 return BLUETOOTH_ERROR_INTERNAL;
1917 g_variant_unref(ret);
1918 BT_INFO("Add white list");
1920 return BLUETOOTH_ERROR_NONE;
1923 int _bt_remove_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
1926 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1927 GError *error = NULL;
1930 if (__bt_is_factory_test_mode()) {
1931 BT_ERR("Unable to remove white list in factory binary !!");
1932 return BLUETOOTH_ERROR_NOT_SUPPORT;
1935 BT_CHECK_PARAMETER(device_address, return);
1937 if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
1938 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
1939 return BLUETOOTH_ERROR_INVALID_PARAM;
1941 _bt_convert_addr_type_to_string(address, device_address->addr);
1943 proxy = _bt_get_adapter_proxy();
1944 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1946 ret = g_dbus_proxy_call_sync(proxy, "RemoveDeviceWhiteList",
1947 g_variant_new("(su)", address, address_type),
1948 G_DBUS_CALL_FLAGS_NONE, -1,
1952 BT_ERR("RemoveDeviceWhiteList Fail: %s", error->message);
1953 g_clear_error(&error);
1954 return BLUETOOTH_ERROR_INTERNAL;
1958 g_variant_unref(ret);
1959 BT_INFO("Remove white list");
1961 return BLUETOOTH_ERROR_NONE;
1964 int _bt_clear_white_list(void)
1967 GError *error = NULL;
1970 if (__bt_is_factory_test_mode()) {
1971 BT_ERR("Unable to clear white list in factory binary !!");
1972 return BLUETOOTH_ERROR_NOT_SUPPORT;
1975 proxy = _bt_get_adapter_proxy();
1976 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1978 ret = g_dbus_proxy_call_sync(proxy, "ClearDeviceWhiteList",
1979 NULL, G_DBUS_CALL_FLAGS_NONE,
1983 BT_ERR("ClearDeviceWhiteList Fail: %s", error->message);
1984 g_clear_error(&error);
1985 return BLUETOOTH_ERROR_INTERNAL;
1988 g_variant_unref(ret);
1990 BT_INFO("Clear white list");
1992 return BLUETOOTH_ERROR_NONE;
1995 int _bt_initialize_ipsp(void)
1999 GError *error = NULL;
2002 if (_bt_adapter_get_status() != BT_ACTIVATED &&
2003 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2004 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2007 proxy = _bt_get_adapter_proxy();
2008 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2010 ret = g_dbus_proxy_call_sync(proxy, "InitializeIpsp",
2011 NULL, G_DBUS_CALL_FLAGS_NONE,
2014 BT_ERR("Initialize IPSP Failed :[%s]", error->message);
2015 g_clear_error(&error);
2016 return BLUETOOTH_ERROR_INTERNAL;
2019 g_variant_unref(ret);
2021 BT_INFO("IPSP initialization called successfully");
2023 return BLUETOOTH_ERROR_NONE;
2026 int _bt_deinitialize_ipsp(void)
2030 GError *error = NULL;
2033 if (_bt_adapter_get_status() != BT_ACTIVATED &&
2034 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2035 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2038 proxy = _bt_get_adapter_proxy();
2039 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2041 ret = g_dbus_proxy_call_sync(proxy, "DeinitializeIpsp",
2042 NULL, G_DBUS_CALL_FLAGS_NONE,
2045 BT_ERR("De-Initialize IPSP Failed :[%s]", error->message);
2046 g_clear_error(&error);
2047 return BLUETOOTH_ERROR_INTERNAL;
2050 g_variant_unref(ret);
2052 BT_INFO("IPSP De-initialization called successfully");
2054 return BLUETOOTH_ERROR_NONE;
2057 int _bt_le_read_maximum_data_length(
2058 bluetooth_le_read_maximum_data_length_t *max_le_datalength)
2060 GError *error = NULL;
2062 GVariant *reply = NULL;
2063 guint16 max_tx_octets, max_tx_time;
2064 guint16 max_rx_octets, max_rx_time;
2066 proxy = _bt_get_adapter_proxy();
2067 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2069 reply = g_dbus_proxy_call_sync(proxy, "LEReadMaximumDataLength",
2070 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2072 if (reply == NULL) {
2073 BT_ERR("LEReadMaximumDataLength dBUS-RPC failed");
2074 if (error != NULL) {
2075 BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
2076 error->code, error->message);
2077 g_clear_error(&error);
2079 return BLUETOOTH_ERROR_INTERNAL;
2082 g_variant_get(reply, "(qqqq)", &max_tx_octets, &max_tx_time,
2083 &max_rx_octets, &max_rx_time);
2085 max_le_datalength->max_tx_octets = max_tx_octets;
2086 max_le_datalength->max_tx_time = max_tx_time;
2087 max_le_datalength->max_rx_octets = max_rx_octets;
2088 max_le_datalength->max_rx_time = max_rx_time;
2090 g_variant_unref(reply);
2092 return BLUETOOTH_ERROR_NONE;
2094 int _bt_le_write_host_suggested_default_data_length(
2095 const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
2097 GError *error = NULL;
2099 GVariant *reply = NULL;
2101 proxy = _bt_get_adapter_proxy();
2102 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2104 reply = g_dbus_proxy_call_sync(proxy,
2105 "LEWriteHostSuggestedDataLength",
2106 g_variant_new("(qq)", def_tx_Octets, def_tx_Time),
2107 G_DBUS_CALL_FLAGS_NONE,
2112 if (reply == NULL) {
2113 BT_ERR("_bt_le_write_host_suggested_default_data_length dBUS-RPC failed");
2114 if (error != NULL) {
2115 BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
2116 error->code, error->message);
2117 g_clear_error(&error);
2119 return BLUETOOTH_ERROR_INTERNAL;
2122 g_variant_unref(reply);
2124 return BLUETOOTH_ERROR_NONE;
2127 int _bt_le_read_host_suggested_default_data_length(
2128 bluetooth_le_read_host_suggested_data_length_t *def_data_length)
2130 GError *error = NULL;
2132 GVariant *reply = NULL;
2133 guint16 def_tx_octets, def_tx_time;
2135 proxy = _bt_get_adapter_proxy();
2136 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2138 reply = g_dbus_proxy_call_sync(proxy, "LEReadHostSuggestedDataLength",
2139 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2141 if (reply == NULL) {
2142 BT_ERR("LEReadHostSuggestedDataLength dBUS-RPC failed");
2143 if (error != NULL) {
2144 BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
2145 error->code, error->message);
2146 g_clear_error(&error);
2148 return BLUETOOTH_ERROR_INTERNAL;
2151 g_variant_get(reply, "(qq)", &def_tx_octets, &def_tx_time);
2153 def_data_length->def_tx_octets = def_tx_octets;
2154 def_data_length->def_tx_time = def_tx_time;
2156 g_variant_unref(reply);
2158 return BLUETOOTH_ERROR_NONE;
2161 int _bt_le_set_data_length(bluetooth_device_address_t *device_address,
2162 const unsigned int max_tx_Octets, const unsigned int max_tx_Time)
2164 GError *error = NULL;
2165 guint16 txOctets = max_tx_Octets;
2166 guint16 txTime = max_tx_Time;
2167 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2168 gchar *device_path = NULL;
2169 GDBusConnection *conn;
2170 GDBusProxy *device_proxy;
2172 _bt_convert_addr_type_to_string(address, device_address->addr);
2174 device_path = _bt_get_device_object_path(address);
2176 if (device_path == NULL) {
2177 BT_DBG("Device path is null");
2178 return BLUETOOTH_ERROR_INTERNAL;
2181 conn = _bt_gdbus_get_system_gconn();
2183 BT_ERR("conn == NULL");
2184 g_free(device_path);
2185 return BLUETOOTH_ERROR_INTERNAL;
2188 device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
2189 NULL, BT_BLUEZ_NAME,
2190 device_path, BT_DEVICE_INTERFACE, NULL, NULL);
2192 g_free(device_path);
2193 retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2195 g_dbus_proxy_call_sync(device_proxy,
2197 g_variant_new("(qq)", txOctets, txTime),
2198 G_DBUS_CALL_FLAGS_NONE,
2203 g_object_unref(device_proxy);
2206 BT_ERR("LESetDataLength error: [%s]", error->message);
2207 g_error_free(error);
2208 return BLUETOOTH_ERROR_INTERNAL;
2211 return BLUETOOTH_ERROR_NONE;
2214 int _bt_service_adapter_le_init(void)
2216 le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
2218 return BLUETOOTH_ERROR_NONE;
2221 void _bt_service_adapter_le_deinit(void)
2223 __bt_free_le_adv_slot();
2224 __bt_free_le_scanner();