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.
19 #include <dbus/dbus.h>
24 #include "bluetooth-api.h"
25 #include "bluetooth-audio-api.h"
26 #include "bt-internal-types.h"
27 #include "bluetooth-media-control.h"
29 #include "bt-common.h"
30 #include "bt-event-handler.h"
31 #include "bt-request-sender.h"
33 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
43 static int obex_server_id;
44 static guint disable_timer_id;
45 static gboolean is_initialized;
46 static GSList *sending_list = NULL;
47 static GSList *server_list = NULL;
48 static GSList *event_list = NULL;
49 static int owner_sig_id = -1;
50 static gboolean is_adapter_enabled = TRUE;
52 void _bt_add_push_request_id(int request_id)
54 bt_sending_info_t *info;
56 info = g_new0(bt_sending_info_t, 1);
57 info->request_id = request_id;
59 sending_list = g_slist_append(sending_list, info);
62 static gboolean __bt_is_request_id_exist(int request_id)
65 bt_sending_info_t *info;
67 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
72 if (info->request_id == request_id)
79 static void __bt_remove_push_request_id(int request_id)
82 bt_sending_info_t *info;
84 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
89 BT_DBG("info->request_id = %d\n", info->request_id);
90 BT_DBG("request_id = %d\n", request_id);
91 if (info->request_id == request_id) {
92 sending_list = g_slist_remove(sending_list, (void *)info);
99 static void __bt_remove_all_push_request_id(void)
102 bt_sending_info_t *info;
104 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
109 g_slist_free(sending_list);
113 static void __bt_remove_all_server(void)
116 bt_server_info_t *info;
118 for (l = server_list; l != NULL; l = g_slist_next(l)) {
123 g_slist_free(server_list);
127 static gboolean __bt_is_server_exist(int server_fd)
130 bt_server_info_t *info;
132 for (l = server_list; l != NULL; l = g_slist_next(l)) {
137 retv_if(info->server_fd == server_fd, TRUE);
143 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
150 ret_if(dev_info == NULL);
151 ret_if(uuids == NULL);
152 ret_if(uuid_count <= 0);
154 dev_info->service_index = uuid_count;
156 for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
157 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
159 parts = g_strsplit(uuids[i], "-", -1);
161 if (parts == NULL || parts[0] == NULL) {
166 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
170 static int __bt_call_list_create(bt_hf_call_list_s **list)
172 bt_hf_call_list_s *handle;
175 BT_DBG("Already Initialized");
176 return BLUETOOTH_ERROR_NONE;
178 handle = g_malloc0(sizeof(bt_hf_call_list_s));
180 return BLUETOOTH_ERROR_NONE;
183 static int __bt_call_list_reset(bt_hf_call_list_s *list)
185 bt_hf_call_list_s *handle;
186 bt_hf_call_status_info_t *call_status;
189 BT_ERR("invalid parameter");
190 return BLUETOOTH_ERROR_INVALID_PARAM;
192 handle = (bt_hf_call_list_s *)list;
194 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(handle->list, 0);
195 if (call_status == NULL)
197 handle->list = g_list_remove(handle->list, call_status);
198 g_free(call_status->number);
201 return BLUETOOTH_ERROR_NONE;
204 static int __bt_call_list_destroy(bt_hf_call_list_s *list)
207 bt_hf_call_list_s *handle;
210 BT_ERR("invalid parameter");
211 return BLUETOOTH_ERROR_INVALID_PARAM;
213 handle = (bt_hf_call_list_s *)list;
214 result = __bt_call_list_reset(list);
218 static int __bt_call_list_add(bt_hf_call_list_s *list, char * number,
219 int dir, int status, int mpart, int idx)
221 bt_hf_call_list_s *handle;
222 bt_hf_call_status_info_t *call_status;
225 BT_ERR("invalid parameter");
226 return BLUETOOTH_ERROR_INVALID_PARAM;
228 handle = (bt_hf_call_list_s *)list;
229 call_status = g_malloc0(sizeof(bt_hf_call_status_info_t));
230 /* Fix : NULL_RETURNS */
231 retv_if(call_status == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
233 call_status->number = g_strdup(number);
234 call_status->direction = dir;
235 call_status->status = status;
236 call_status->mpart = mpart;
237 call_status->idx = idx;
238 handle->list = g_list_append(handle->list, (gpointer)call_status);
239 return BLUETOOTH_ERROR_NONE;
242 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
244 bluetooth_device_info_t *dev_info;
245 const char *address = NULL;
246 const char *name = NULL;
247 gchar **uuids = NULL;
248 unsigned int dev_class = 0;
250 gboolean paired = FALSE;
252 gboolean trust = FALSE;
254 int result = BLUETOOTH_ERROR_NONE;
255 GVariant *string_var;
257 int manufacturer_data_len = 0;
258 GVariant *manufacturer_var = NULL;
259 const char *manufacturer_data = NULL;
261 g_variant_get(parameters, "(isunsbub@asn@ay)", &result, &address,
262 &dev_class, &rssi, &name, &paired,
263 &connected, &trust, &string_var, &manufacturer_data_len, &manufacturer_var);
265 if (string_var == NULL) {
266 BT_ERR("invalid parameters in signal");
270 uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
272 len = g_variant_get_size(manufacturer_var);
274 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
276 dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
277 /* Fix : NULL_RETURNS */
278 if (dev_info == NULL) {
279 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
283 dev_info->rssi = rssi;
284 dev_info->paired = paired;
285 dev_info->connected = connected;
286 dev_info->trust = trust;
288 g_strlcpy(dev_info->device_name.name, name,
289 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
291 _bt_divide_device_class(&dev_info->device_class, dev_class);
293 _bt_convert_addr_string_to_type(dev_info->device_address.addr,
297 __bt_get_uuid_info(dev_info, uuids, uuid_count);
299 if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
300 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
301 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
303 dev_info->manufacturer_data.data_len = manufacturer_data_len;
304 if (manufacturer_data)
305 for (i = 0; i < manufacturer_data_len; i++)
306 dev_info->manufacturer_data.data[i] = manufacturer_data[i];
310 g_variant_unref(string_var);
311 g_variant_unref(manufacturer_var);
315 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
317 bluetooth_le_device_info_t *le_dev_info;
318 const char *address = NULL;
323 int adv_data_len = 0;
324 GVariant *adv_var = NULL;
325 const char *adv_data = NULL;
326 int scan_data_len = 0;
327 GVariant *scan_var = NULL;
328 const char *scan_data = NULL;
329 int result = BLUETOOTH_ERROR_NONE;
331 g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
332 &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
334 len = g_variant_get_size(adv_var);
336 adv_data = (char *)g_variant_get_data(adv_var);
338 len = g_variant_get_size(scan_var);
340 scan_data = (char *)g_variant_get_data(scan_var);
342 le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
343 /* Fix : NULL_RETURNS */
344 if (le_dev_info == NULL) {
345 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
348 _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
349 le_dev_info->addr_type = addr_type;
350 le_dev_info->rssi = rssi;
351 le_dev_info->adv_ind_data.data_len = adv_data_len;
353 for (i = 0; i < adv_data_len; i++)
355 le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
357 le_dev_info->scan_resp_data.data_len = scan_data_len;
359 for (i = 0; i < scan_data_len; i++)
361 le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
366 g_variant_unref(adv_var);
367 g_variant_unref(scan_var);
371 gboolean __bt_reliable_disable_cb(gpointer user_data)
374 bt_event_info_t *event_info = user_data;
376 _bt_set_le_scan_status(FALSE);
378 if (is_initialized != FALSE) {
379 if (is_adapter_enabled == TRUE) {
380 is_adapter_enabled = FALSE;
381 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
382 BLUETOOTH_ERROR_NONE, NULL,
383 event_info->cb, event_info->user_data);
384 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
385 BLUETOOTH_ERROR_NONE, NULL,
386 event_info->cb, event_info->user_data);
390 obex_server_id = BT_NO_SERVER;
391 __bt_remove_all_server();
392 __bt_remove_all_push_request_id();
394 _bt_rfcomm_server_free_all();
400 void __bt_adapter_event_filter(GDBusConnection *connection,
401 const gchar *sender_name,
402 const gchar *object_path,
403 const gchar *interface_name,
404 const gchar *signal_name,
405 GVariant *parameters,
408 bt_event_info_t *event_info;
409 int result = BLUETOOTH_ERROR_NONE;
411 event_info = (bt_event_info_t *)user_data;
412 ret_if(event_info == NULL);
414 if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
416 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
419 if (strcasecmp(signal_name, BT_ENABLED) == 0) {
420 BT_INFO("BT_ENABLED");
421 g_variant_get(parameters, "(i)", &result);
422 if (result == BLUETOOTH_ERROR_NONE) {
423 if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
424 BT_ERR("Set vconf failed");
426 if (vconf_set_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, 0) != 0)
427 BT_ERR("Set vconf failed");
429 if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 0) != 0)
430 BT_ERR("Set vconf failed");
433 is_adapter_enabled = TRUE;
435 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
437 event_info->cb, event_info->user_data);
438 } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
439 BT_INFO("BT_DISABLED");
440 int flight_mode_value = 0;
441 int ps_mode_value = 0;
443 if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE,
444 &flight_mode_value) != 0)
445 BT_ERR("Fail to get the flight_mode_deactivated value");
447 if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE,
448 &ps_mode_value) != 0)
449 BT_ERR("Fail to get the ps_mode_deactivated value");
451 if (flight_mode_value == 1 || ps_mode_value > 0) {
452 BT_INFO("Flight mode deactivation");
453 if (disable_timer_id > 0)
454 g_source_remove(disable_timer_id);
456 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
457 (GSourceFunc)__bt_reliable_disable_cb,
460 is_adapter_enabled = FALSE;
462 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
464 event_info->cb, event_info->user_data);
467 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
469 event_info->cb, event_info->user_data);
470 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
473 g_variant_get(parameters, "(in)", &result, &mode);
474 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
476 event_info->cb, event_info->user_data);
477 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
480 g_variant_get(parameters, "(in)", &result, &timeout);
481 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
483 event_info->cb, event_info->user_data);
484 } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
485 gboolean connectable = FALSE;
487 g_variant_get(parameters, "(b)", &connectable);
488 BT_DBG("Connectable is changed : %d", connectable);
490 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
491 result, &connectable,
492 event_info->cb, event_info->user_data);
493 } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
494 char *adapter_name = NULL;
496 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
497 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
498 result, adapter_name,
499 event_info->cb, event_info->user_data);
500 } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
501 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
502 BLUETOOTH_ERROR_NONE, NULL,
503 event_info->cb, event_info->user_data);
504 } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
505 g_variant_get(parameters, "(i)", &result);
506 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
508 event_info->cb, event_info->user_data);
509 } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
512 g_variant_get(parameters, "(ii)", &result, &adv_handle);
513 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
515 event_info->cb, event_info->user_data);
516 } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
519 g_variant_get(parameters, "(ii)", &result, &adv_handle);
520 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
522 event_info->cb, event_info->user_data);
523 } else if (strcasecmp(signal_name, BT_ADVERTISING_MANUFACTURER_DATA_CHANGED) == 0) {
524 GVariant *var = NULL;
528 g_variant_get(parameters, "(@ay)", &var);
529 len = g_variant_get_size(var);
530 data = (char *)g_variant_get_data(var);
532 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
534 event_info->cb, event_info->user_data);
536 g_variant_unref(var);
537 } else if (strcasecmp(signal_name, BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
538 GVariant *var = NULL;
542 g_variant_get(parameters, "(@ay)", &var);
543 len = g_variant_get_size(var);
544 data = (char *)g_variant_get_data(var);
546 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
548 event_info->cb, event_info->user_data);
550 g_variant_unref(var);
551 } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
552 GVariant *var = NULL;
556 g_variant_get(parameters, "(@ay)", &var);
557 len = g_variant_get_size(var);
558 data = (char *)g_variant_get_data(var);
560 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
562 event_info->cb, event_info->user_data);
564 g_variant_unref(var);
565 } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
567 bluetooth_device_info_t *device_info;
569 device_info = __bt_get_device_info_in_message(parameters,
571 ret_if(device_info == NULL);
573 if (strlen(device_info->device_name.name) > 0)
574 event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
576 event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
578 _bt_common_event_cb(event,
580 event_info->cb, event_info->user_data);
583 } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
584 bluetooth_device_info_t *device_info;
586 device_info = __bt_get_device_info_in_message(parameters,
588 ret_if(device_info == NULL);
590 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
592 event_info->cb, event_info->user_data);
595 } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
596 const char *address = NULL;
597 bluetooth_device_address_t dev_address = { {0} };
599 g_variant_get(parameters, "(i&s)", &result, &address);
601 _bt_convert_addr_string_to_type(dev_address.addr,
604 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
605 result, &dev_address,
606 event_info->cb, event_info->user_data);
607 } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
608 bluetooth_device_info_t *device_info;
609 bt_sdp_info_t sdp_info;
611 device_info = __bt_get_device_info_in_message(parameters,
613 ret_if(device_info == NULL);
615 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
617 sdp_info.service_index = device_info->service_index;
619 memcpy(&sdp_info.device_addr,
620 &device_info->device_address,
621 BLUETOOTH_ADDRESS_LENGTH);
623 memcpy(sdp_info.service_list_array,
624 device_info->service_list_array,
625 BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
627 memcpy(sdp_info.uuids,
629 BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
631 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
633 event_info->cb, event_info->user_data);
636 } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
637 gboolean ipsp_intialized = FALSE;
638 g_variant_get(parameters, "(b)", &ipsp_intialized);
640 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
642 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
643 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
644 event_info->cb, event_info->user_data);
645 } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
646 const char *address = NULL;
647 const char *name = NULL;
648 const char *str_passkey = NULL;
650 bluetooth_authentication_request_info_t auth_info;
651 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
653 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
655 g_strlcpy(auth_info.device_name.name, name,
656 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
657 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
659 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
661 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
663 event_info->cb, event_info->user_data);
664 } else if (strcasecmp(signal_name, BT_PIN_REQ_RECEIVED) == 0) {
665 const char *address = NULL;
666 const char *name = NULL;
668 bluetooth_authentication_request_info_t auth_info;
669 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
671 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
673 g_strlcpy(auth_info.device_name.name, name,
674 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
675 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
678 _bt_common_event_cb(BLUETOOTH_EVENT_PIN_REQUEST,
680 event_info->cb, event_info->user_data);
681 } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
682 const char *address = NULL;
683 const char *name = NULL;
685 bluetooth_authentication_request_info_t auth_info;
686 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
688 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
690 g_strlcpy(auth_info.device_name.name, name,
691 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
692 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
695 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
697 event_info->cb, event_info->user_data);
698 } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
699 const char *address = NULL;
700 const char *name = NULL;
701 const char *str_passkey = NULL;
703 bluetooth_authentication_request_info_t auth_info;
704 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
706 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
708 g_strlcpy(auth_info.device_name.name, name,
709 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
710 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
712 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
714 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
716 event_info->cb, event_info->user_data);
720 void __bt_adapter_le_event_filter(GDBusConnection *connection,
721 const gchar *sender_name,
722 const gchar *object_path,
723 const gchar *interface_name,
724 const gchar *signal_name,
725 GVariant *parameters,
728 bt_event_info_t *event_info;
729 int result = BLUETOOTH_ERROR_NONE;
731 event_info = (bt_event_info_t *)user_data;
732 ret_if(event_info == NULL);
734 if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
736 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
739 if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
740 BT_INFO("BT_LE_ENABLED");
741 g_variant_get(parameters, "(i)", &result);
742 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
744 event_info->cb, event_info->user_data);
745 } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
746 BT_INFO("BT_LE_DISABLED");
747 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
749 event_info->cb, event_info->user_data);
750 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
751 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
752 BLUETOOTH_ERROR_NONE, NULL,
753 event_info->cb, event_info->user_data);
754 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
755 g_variant_get(parameters, "(i)", &result);
756 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
758 event_info->cb, event_info->user_data);
759 } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
760 bluetooth_le_device_info_t *le_device_info;
762 le_device_info = __bt_get_le_device_info_in_message(parameters,
764 ret_if(le_device_info == NULL);
766 _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
767 result, le_device_info,
768 event_info->cb, event_info->user_data);
770 g_free(le_device_info);
774 void __bt_device_event_filter(GDBusConnection *connection,
775 const gchar *sender_name,
776 const gchar *object_path,
777 const gchar *interface_name,
778 const gchar *signal_name,
779 GVariant *parameters,
782 bt_event_info_t *event_info;
783 int result = BLUETOOTH_ERROR_NONE;
785 event_info = (bt_event_info_t *)user_data;
786 ret_if(event_info == NULL);
789 gboolean gatt_interface = FALSE;
791 if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
792 gatt_interface = TRUE;
794 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
795 gatt_interface == FALSE)
797 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
798 gatt_interface == FALSE)
801 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0)
803 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
807 ret_if(signal_name == NULL);
809 if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
810 const char *address = NULL;
811 bluetooth_device_address_t dev_address = { {0} };
812 BT_DBG("BT_GATT_CONNECTED");
813 g_variant_get(parameters, "(i&s)", &result, &address);
815 _bt_convert_addr_string_to_type(dev_address.addr, address);
816 BT_DBG("Sending Event to Framework");
817 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
818 result, &dev_address,
819 event_info->cb, event_info->user_data);
820 } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
821 const char *address = NULL;
822 bluetooth_device_address_t dev_address = { {0} };
823 BT_DBG("BT_GATT_DISCONNECTED");
824 g_variant_get(parameters, "(i&s)", &result, &address);
826 _bt_convert_addr_string_to_type(dev_address.addr, address);
827 BT_DBG("Sending Event to Framework");
828 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
829 result, &dev_address,
830 event_info->cb, event_info->user_data);
832 } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
834 } else if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) {
836 const char *char_handle = NULL;
838 const char * value = NULL;
839 GVariant *char_value_var = NULL;
840 bt_gatt_char_value_t char_val = { 0, };
841 BT_DBG("BT_GATT_CHAR_VAL_CHANGED");
843 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
845 len = g_variant_get_size(char_value_var);
847 value = (char *)g_variant_get_data(char_value_var);
849 char_val.char_handle = g_strdup(char_handle);
850 char_val.val_len = len;
851 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
852 if (char_val.val_len > 0 && value != NULL) {
853 char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
854 /* Fix : NULL_RETURNS */
855 if (char_val.char_value == NULL) {
856 BT_ERR("BLUETOOTH_ERROR_OUT_OF_MEMORY");
857 g_free(char_val.char_handle);
859 g_variant_unref(char_value_var);
862 memcpy(char_val.char_value, value, len);
863 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
865 event_info->cb, event_info->user_data);
866 g_free(char_val.char_value);
868 g_variant_unref(char_value_var);
870 g_free(char_val.char_handle);
871 } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
872 const char *address = NULL;
873 unsigned char addr_type;
874 bt_connection_info_t conn_info;
875 bluetooth_device_address_t dev_address = { {0} };
876 BT_DBG("BT_DEVICE_CONNECTED");
877 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
879 _bt_convert_addr_string_to_type(dev_address.addr,
882 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
884 memcpy(conn_info.device_addr.addr,
886 BLUETOOTH_ADDRESS_LENGTH);
888 conn_info.addr_type = addr_type;
889 conn_info.disc_reason = 0;
890 BT_DBG("Sending Event to Framework");
891 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
893 event_info->cb, event_info->user_data);
895 } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
896 const char *address = NULL;
897 unsigned char addr_type;
898 bt_connection_info_t conn_info;
899 bluetooth_device_address_t dev_address = { {0} };
900 BT_DBG("BT_DEVICE_DISCONNECTED");
901 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
903 _bt_convert_addr_string_to_type(dev_address.addr,
906 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
908 memcpy(conn_info.device_addr.addr,
910 BLUETOOTH_ADDRESS_LENGTH);
912 conn_info.addr_type = addr_type;
913 conn_info.disc_reason = result;
914 BT_DBG("Sending Event to Framework");
915 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
917 event_info->cb, event_info->user_data);
919 } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
920 bt_rssi_enabled_t enabled = { 0, };
923 gboolean rssi_enabled = FALSE;
925 g_variant_get(parameters, "(isib)", &result, &address,
926 &link_type, &rssi_enabled);
928 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
929 address, link_type, rssi_enabled);
930 enabled.address = address;
931 enabled.link_type = link_type;
932 enabled.rssi_enabled = rssi_enabled;
934 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
936 event_info->cb, event_info->user_data);
937 } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
942 bt_rssi_alert_t alert = { 0, };
944 g_variant_get(parameters, "(isiii)", &result, &address,
945 &link_type, &alert_type, &rssi_dbm);
947 alert.alert_type = alert_type;
948 alert.rssi_dbm = rssi_dbm;
949 alert.address = address;
950 alert.link_type = link_type;
951 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
952 address, link_type, alert_type, rssi_dbm);
953 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
955 event_info->cb, event_info->user_data);
956 } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
960 bt_raw_rssi_t raw_rssi = { 0, };
962 g_variant_get(parameters, "(isii)", &result,
963 &address, &link_type, &rssi_dbm);
965 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
966 address, link_type, rssi_dbm);
968 raw_rssi.rssi_dbm = rssi_dbm;
969 raw_rssi.address = address;
970 raw_rssi.link_type = link_type;
972 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
974 event_info->cb, event_info->user_data);
975 } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
976 const char *address = NULL;
977 bluetooth_device_address_t dev_address = { {0} };
979 g_variant_get(parameters, "(i&s)", &result, &address);
981 _bt_convert_addr_string_to_type(dev_address.addr,
984 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
985 result, &dev_address,
986 event_info->cb, event_info->user_data);
987 } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
988 const char *address = NULL;
989 bluetooth_device_address_t dev_address = { {0} };
991 g_variant_get(parameters, "(i&s)", &result, &address);
993 _bt_convert_addr_string_to_type(dev_address.addr,
996 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
997 result, &dev_address,
998 event_info->cb, event_info->user_data);
999 } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1000 const char *address = NULL;
1001 bluetooth_device_address_t dev_address = { {0} };
1003 BT_DBG("BT_IPSP_CONNECTED");
1004 g_variant_get(parameters, "(i&s)", &result, &address);
1006 _bt_convert_addr_string_to_type(dev_address.addr, address);
1008 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1009 result, &dev_address,
1010 event_info->cb, event_info->user_data);
1011 } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1012 const char *address = NULL;
1013 bluetooth_device_address_t dev_address = { {0} };
1014 BT_DBG("BT_IPSP_DISCONNECTED");
1016 g_variant_get(parameters, "(i&s)", &result, &address);
1018 _bt_convert_addr_string_to_type(dev_address.addr, address);
1020 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1021 result, &dev_address,
1022 event_info->cb, event_info->user_data);
1023 } else if (strcasecmp(signal_name, BT_IPSP_BT_INTERFACE_INFO) == 0) {
1024 const char *address = NULL;
1025 const char *if_name = NULL;
1026 bt_ipsp_interface_info_t ipsp_iface_info;
1027 memset(&ipsp_iface_info, 0, sizeof(ipsp_iface_info));
1029 BT_DBG("BT_IPSP_BT_INTERFACE_INFO");
1030 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1032 _bt_convert_addr_string_to_type(ipsp_iface_info.btaddr.addr, address);
1033 memcpy(ipsp_iface_info.if_name, if_name, 16);
1035 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO,
1036 result, &ipsp_iface_info,
1037 event_info->cb, event_info->user_data);
1038 } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1039 const char *address = NULL;
1040 bluetooth_device_address_t dev_address = { {0} };
1045 bt_le_data_length_params_t params;
1047 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1049 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1050 tx_octets, tx_time, rx_octets, rx_time);
1052 params.max_tx_octets = tx_octets;
1053 params.max_tx_time = tx_time;
1054 params.max_rx_octets = rx_octets;
1055 params.max_rx_time = rx_time;
1057 _bt_convert_addr_string_to_type(dev_address.addr, address);
1059 memcpy(¶ms.device_address,
1060 &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1062 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1063 result, ¶ms, event_info->cb, event_info->user_data);
1067 void __bt_hid_event_filter(GDBusConnection *connection,
1068 const gchar *sender_name,
1069 const gchar *object_path,
1070 const gchar *interface_name,
1071 const gchar *signal_name,
1072 GVariant *parameters,
1075 bt_event_info_t *event_info;
1076 int result = BLUETOOTH_ERROR_NONE;
1078 event_info = (bt_event_info_t *)user_data;
1079 ret_if(event_info == NULL);
1081 if (strcasecmp(object_path, BT_HID_PATH) != 0)
1083 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1086 ret_if(signal_name == NULL);
1088 if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1089 const char *address = NULL;
1090 bluetooth_device_address_t dev_address = { {0} };
1092 g_variant_get(parameters, "(i&s)", &result, &address);
1094 _bt_convert_addr_string_to_type(dev_address.addr,
1097 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1098 result, &dev_address,
1099 event_info->cb, event_info->user_data);
1100 } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1101 const char *address = NULL;
1102 bluetooth_device_address_t dev_address = { {0} };
1104 g_variant_get(parameters, "(i&s)", &result, &address);
1106 BT_DBG("address: %s", address);
1108 _bt_convert_addr_string_to_type(dev_address.addr,
1111 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1112 result, &dev_address,
1113 event_info->cb, event_info->user_data);
1117 void __bt_headset_event_filter(GDBusConnection *connection,
1118 const gchar *sender_name,
1119 const gchar *object_path,
1120 const gchar *interface_name,
1121 const gchar *signal_name,
1122 GVariant *parameters,
1125 bt_event_info_t *event_info;
1126 int result = BLUETOOTH_ERROR_NONE;
1127 event_info = (bt_event_info_t *)user_data;
1128 ret_if(event_info == NULL);
1130 if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1132 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1135 ret_if(signal_name == NULL);
1137 if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1138 char *address = NULL;
1140 g_variant_get(parameters, "(i&s)", &result, &address);
1142 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1144 event_info->cb, event_info->user_data);
1145 } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1146 char *address = NULL;
1148 g_variant_get(parameters, "(i&s)", &result, &address);
1150 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1152 event_info->cb, event_info->user_data);
1153 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1154 char *address = NULL;
1156 g_variant_get(parameters, "(i&s)", &result, &address);
1158 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1160 event_info->cb, event_info->user_data);
1161 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1162 char *address = NULL;
1164 g_variant_get(parameters, "(i&s)", &result, &address);
1166 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1168 event_info->cb, event_info->user_data);
1169 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1170 char *address = NULL;
1172 g_variant_get(parameters, "(i&s)", &result, &address);
1173 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1175 event_info->cb, event_info->user_data);
1176 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1177 char *address = NULL;
1179 g_variant_get(parameters, "(i&s)", &result, &address);
1181 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1183 event_info->cb, event_info->user_data);
1184 } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1187 char *address = NULL;
1189 g_variant_get(parameters, "(i&sq)", &result, &address,
1191 gain = (unsigned int)spkr_gain;
1193 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1195 event_info->cb, event_info->user_data);
1196 } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1199 char *address = NULL;
1201 g_variant_get(parameters, "(i&sq)", &result,
1202 &address, &mic_gain);
1203 gain = (unsigned int)mic_gain;
1205 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1207 event_info->cb, event_info->user_data);
1211 void __bt_hid_device_event_filter(GDBusConnection *connection,
1212 const gchar *sender_name,
1213 const gchar *object_path,
1214 const gchar *interface_name,
1215 const gchar *signal_name,
1216 GVariant *parameters,
1219 bt_event_info_t *event_info;
1220 int result = BLUETOOTH_ERROR_NONE;
1222 event_info = (bt_event_info_t *)user_data;
1223 ret_if(event_info == NULL);
1225 if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1227 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1230 ret_if(signal_name == NULL);
1232 if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1233 const char *address = NULL;
1234 bluetooth_device_address_t dev_address = { {0} };
1236 g_variant_get(parameters, "(i&s)", &result, &address);
1238 _bt_convert_addr_string_to_type(dev_address.addr,
1241 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1242 result, &dev_address,
1243 event_info->cb, event_info->user_data);
1244 } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1245 const char *address = NULL;
1246 bluetooth_device_address_t dev_address = { {0} };
1248 g_variant_get(parameters, "(i&s)", &result, &address);
1250 BT_DBG("address: %s", address);
1252 _bt_convert_addr_string_to_type(dev_address.addr,
1255 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1256 result, &dev_address,
1257 event_info->cb, event_info->user_data);
1260 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1261 const gchar *sender_name,
1262 const gchar *object_path,
1263 const gchar *interface_name,
1264 const gchar *signal_name,
1265 GVariant *parameters,
1268 bt_event_info_t *event_info;
1269 int result = BLUETOOTH_ERROR_NONE;
1270 event_info = (bt_event_info_t *)user_data;
1271 ret_if(event_info == NULL);
1273 if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1275 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1278 ret_if(signal_name == NULL);
1280 if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1281 char *address = NULL;
1283 g_variant_get(parameters, "(i&s)", &result, &address);
1284 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1286 event_info->cb, event_info->user_data);
1287 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1288 char *address = NULL;
1290 g_variant_get(parameters, "(i&s)", &result, &address);
1292 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1294 event_info->cb, event_info->user_data);
1298 void __bt_network_event_filter(GDBusConnection *connection,
1299 const gchar *sender_name,
1300 const gchar *object_path,
1301 const gchar *interface_name,
1302 const gchar *signal_name,
1303 GVariant *parameters,
1306 bt_event_info_t *event_info;
1307 int result = BLUETOOTH_ERROR_NONE;
1308 event_info = (bt_event_info_t *)user_data;
1309 ret_if(event_info == NULL);
1311 if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1313 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1316 ret_if(signal_name == NULL);
1318 if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1319 const char *address = NULL;
1320 bluetooth_device_address_t dev_address = { {0} };
1322 g_variant_get(parameters, "(i&s)", &result, &address);
1324 _bt_convert_addr_string_to_type(dev_address.addr,
1327 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1328 result, &dev_address,
1329 event_info->cb, event_info->user_data);
1330 } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1331 const char *address = NULL;
1332 bluetooth_device_address_t dev_address = { {0} };
1334 g_variant_get(parameters, "(i&s)", &result, &address);
1336 _bt_convert_addr_string_to_type(dev_address.addr,
1339 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1340 result, &dev_address,
1341 event_info->cb, event_info->user_data);
1342 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1343 const char *device = NULL;
1344 const char *address = NULL;
1345 bluetooth_network_device_info_t network_info;
1347 g_variant_get(parameters, "(i&s&s)", &result,
1350 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1352 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1355 _bt_print_device_address_t(&network_info.device_address);
1356 g_strlcpy(network_info.interface_name, device,
1357 sizeof(network_info.interface_name));
1359 DBG_SECURE("Interface: %s", network_info.interface_name);
1361 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1362 result, &network_info,
1363 event_info->cb, event_info->user_data);
1364 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1365 const char *device = NULL;
1366 const char *address = NULL;
1367 bluetooth_network_device_info_t network_info;
1369 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1371 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1373 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1376 _bt_print_device_address_t(&network_info.device_address);
1378 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1379 result, &network_info,
1380 event_info->cb, event_info->user_data);
1384 void __bt_avrcp_event_filter(GDBusConnection *connection,
1385 const gchar *sender_name,
1386 const gchar *object_path,
1387 const gchar *interface_name,
1388 const gchar *signal_name,
1389 GVariant *parameters,
1392 bt_event_info_t *event_info;
1393 int result = BLUETOOTH_ERROR_NONE;
1394 event_info = (bt_event_info_t *)user_data;
1395 ret_if(event_info == NULL);
1397 if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1399 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1402 ret_if(signal_name == NULL);
1404 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1405 char *address = NULL;
1407 g_variant_get(parameters, "(i&s)", &result, &address);
1409 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1411 event_info->cb, event_info->user_data);
1412 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1413 char *address = NULL;
1415 g_variant_get(parameters, "(i&s)", &result, &address);
1417 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1419 event_info->cb, event_info->user_data);
1420 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1421 unsigned int status;
1423 g_variant_get(parameters, "(u)", &status);
1424 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1426 event_info->cb, event_info->user_data);
1427 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1428 unsigned int status;
1430 g_variant_get(parameters, "(u)", &status);
1431 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1433 event_info->cb, event_info->user_data);
1434 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1435 unsigned int status;
1437 g_variant_get(parameters, "(u)", &status);
1438 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1440 event_info->cb, event_info->user_data);
1441 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1442 unsigned int status;
1444 g_variant_get(parameters, "(u)", &status);
1445 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1447 event_info->cb, event_info->user_data);
1451 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1452 const gchar *sender_name,
1453 const gchar *object_path,
1454 const gchar *interface_name,
1455 const gchar *signal_name,
1456 GVariant *parameters,
1459 bt_event_info_t *event_info;
1460 int result = BLUETOOTH_ERROR_NONE;
1461 event_info = (bt_event_info_t *)user_data;
1462 ret_if(event_info == NULL);
1464 if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1466 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1469 ret_if(signal_name == NULL);
1471 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1472 char *address = NULL;
1474 g_variant_get(parameters, "(i&s)", &result, &address);
1476 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1478 event_info->cb, event_info->user_data);
1479 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1480 char *address = NULL;
1482 g_variant_get(parameters, "(i&s)", &result, &address);
1484 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1486 event_info->cb, event_info->user_data);
1487 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1488 unsigned int status;
1490 g_variant_get(parameters, "(u)", &status);
1491 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1493 event_info->cb, event_info->user_data);
1494 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1495 unsigned int status;
1497 g_variant_get(parameters, "(u)", &status);
1498 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1500 event_info->cb, event_info->user_data);
1501 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1502 unsigned int status;
1504 g_variant_get(parameters, "(u)", &status);
1505 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1507 event_info->cb, event_info->user_data);
1508 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1509 unsigned int status;
1511 g_variant_get(parameters, "(u)", &status);
1512 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1514 event_info->cb, event_info->user_data);
1515 } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1516 unsigned int status;
1518 g_variant_get(parameters, "(u)", &status);
1519 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1521 event_info->cb, event_info->user_data);
1522 } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1523 unsigned int status;
1525 g_variant_get(parameters, "(u)", &status);
1526 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1528 event_info->cb, event_info->user_data);
1529 } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1530 media_metadata_attributes_t metadata;
1535 unsigned int total_tracks;
1536 unsigned int number;
1537 unsigned int duration;
1539 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1540 &artist, &album, &genre,
1541 &total_tracks, &number,
1543 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1545 metadata.title = title;
1546 metadata.artist = artist;
1547 metadata.album = album;
1548 metadata.genre = genre;
1549 metadata.total_tracks = total_tracks;
1550 metadata.number = number;
1551 metadata.duration = (int64_t)duration;
1553 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1555 event_info->cb, event_info->user_data);
1559 void __bt_opp_client_event_filter(GDBusConnection *connection,
1560 const gchar *sender_name,
1561 const gchar *object_path,
1562 const gchar *interface_name,
1563 const gchar *signal_name,
1564 GVariant *parameters,
1567 bt_event_info_t *event_info;
1568 int result = BLUETOOTH_ERROR_NONE;
1569 event_info = (bt_event_info_t *)user_data;
1570 ret_if(event_info == NULL);
1572 if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1574 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1577 ret_if(signal_name == NULL);
1579 if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1580 const char *address = NULL;
1582 bluetooth_device_address_t dev_address = { {0} };
1584 g_variant_get(parameters, "(i&si)", &result,
1585 &address, &request_id);
1587 if (__bt_is_request_id_exist(request_id) == FALSE) {
1588 BT_ERR("Different request id!");
1592 _bt_convert_addr_string_to_type(dev_address.addr,
1595 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1596 result, &dev_address,
1597 event_info->cb, event_info->user_data);
1599 if (result != BLUETOOTH_ERROR_NONE) {
1600 __bt_remove_push_request_id(request_id);
1602 } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1603 const char *address = NULL;
1605 bluetooth_device_address_t dev_address = { {0} };
1607 g_variant_get(parameters, "(i&si)", &result, &address,
1610 if (__bt_is_request_id_exist(request_id) == FALSE) {
1611 BT_ERR("Different request id!");
1615 _bt_convert_addr_string_to_type(dev_address.addr,
1618 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1619 result, &dev_address,
1620 event_info->cb, event_info->user_data);
1622 __bt_remove_push_request_id(request_id);
1623 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1624 const char *file_name = NULL;
1627 bt_opc_transfer_info_t transfer_info;
1629 g_variant_get(parameters, "(i&sti)", &result, &file_name,
1630 &size, &request_id);
1632 if (__bt_is_request_id_exist(request_id) == FALSE) {
1633 BT_ERR("Different request id!");
1637 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1639 transfer_info.filename = g_strdup(file_name);
1640 transfer_info.size = size;
1642 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1643 result, &transfer_info,
1644 event_info->cb, event_info->user_data);
1646 g_free(transfer_info.filename);
1647 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1648 const char *file_name = NULL;
1652 bt_opc_transfer_info_t transfer_info;
1654 g_variant_get(parameters, "(i&stii)", &result,
1655 &file_name, &size, &progress, &request_id);
1657 if (__bt_is_request_id_exist(request_id) == FALSE) {
1658 BT_ERR("Different request id!");
1662 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1664 transfer_info.filename = g_strdup(file_name);
1665 transfer_info.size = size;
1666 transfer_info.percentage = progress;
1668 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1669 result, &transfer_info,
1670 event_info->cb, event_info->user_data);
1672 g_free(transfer_info.filename);
1673 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1674 const char *file_name = NULL;
1677 bt_opc_transfer_info_t transfer_info;
1679 g_variant_get(parameters, "(i&sti)", &result,
1680 &file_name, &size, &request_id);
1682 if (__bt_is_request_id_exist(request_id) == FALSE) {
1683 BT_ERR("Different request id!");
1687 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1689 transfer_info.filename = g_strdup(file_name);
1690 transfer_info.size = size;
1692 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1693 result, &transfer_info,
1694 event_info->cb, event_info->user_data);
1696 g_free(transfer_info.filename);
1700 void __bt_opp_server_event_filter(GDBusConnection *connection,
1701 const gchar *sender_name,
1702 const gchar *object_path,
1703 const gchar *interface_name,
1704 const gchar *signal_name,
1705 GVariant *parameters,
1708 bt_event_info_t *event_info;
1709 int result = BLUETOOTH_ERROR_NONE;
1710 event_info = (bt_event_info_t *)user_data;
1711 ret_if(event_info == NULL);
1713 if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1715 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1718 ret_if(signal_name == NULL);
1720 if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1721 /* Native only event */
1722 const char *file_name = NULL;
1724 bt_obex_server_authorize_into_t auth_info;
1726 g_variant_get(parameters, "(i&st)", &result, &file_name, &size);
1728 /* OSP server: Don't get this event */
1729 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1731 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1733 auth_info.filename = g_strdup(file_name);
1734 auth_info.length = size;
1736 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1738 event_info->cb, event_info->user_data);
1740 g_free(auth_info.filename);
1741 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1742 /* OSP only event */
1743 const char *address = NULL;
1744 const char *name = NULL;
1745 bluetooth_device_address_t dev_address = { {0} };
1747 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1749 /* Native server: Don't get this event */
1750 ret_if(obex_server_id == BT_NATIVE_SERVER);
1752 _bt_convert_addr_string_to_type(dev_address.addr,
1755 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1756 result, &dev_address,
1757 event_info->cb, event_info->user_data);
1758 } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1760 g_variant_get(parameters, "(i)", &result);
1762 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1763 result, NULL, event_info->cb,
1764 event_info->user_data);
1765 } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1767 g_variant_get(parameters, "(i)", &result);
1769 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1770 result, NULL, event_info->cb,
1771 event_info->user_data);
1772 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1773 const char *file_name = NULL;
1774 const char *type = NULL;
1775 int transfer_id = 0;
1776 int server_type = 0; /* bt_server_type_t */
1778 bt_obex_server_transfer_info_t transfer_info;
1780 g_variant_get(parameters, "(i&s&stii)", &result, &file_name,
1781 &type, &size, &transfer_id, &server_type);
1783 /* Other server's event */
1784 ret_if(obex_server_id != server_type &&
1785 server_type != BT_FTP_SERVER);
1787 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1789 transfer_info.filename = g_strdup(file_name);
1790 transfer_info.type = g_strdup(type);
1791 transfer_info.file_size = size;
1792 transfer_info.transfer_id = transfer_id;
1793 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1794 FTP_SERVER : OPP_SERVER;
1796 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1797 result, &transfer_info,
1798 event_info->cb, event_info->user_data);
1800 g_free(transfer_info.filename);
1801 g_free(transfer_info.type);
1802 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1803 const char *file_name = NULL;
1804 const char *type = NULL;
1805 int transfer_id = 0;
1807 int server_type = 0; /* bt_server_type_t */
1809 bt_obex_server_transfer_info_t transfer_info;
1811 g_variant_get(parameters, "(i&s&stiii)", &result, &file_name,
1812 &type, &size, &transfer_id,
1813 &progress, &server_type);
1815 /* Other server's event */
1816 ret_if(obex_server_id != server_type &&
1817 server_type != BT_FTP_SERVER);
1819 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1821 transfer_info.filename = g_strdup(file_name);
1822 transfer_info.type = g_strdup(type);
1823 transfer_info.file_size = size;
1824 transfer_info.transfer_id = transfer_id;
1825 transfer_info.percentage = progress;
1826 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1827 FTP_SERVER : OPP_SERVER;
1829 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1830 result, &transfer_info,
1831 event_info->cb, event_info->user_data);
1833 g_free(transfer_info.filename);
1834 g_free(transfer_info.type);
1835 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1836 const char *file_name = NULL;
1837 const char *device_name = NULL;
1838 const char *type = NULL;
1839 const char *file_path;
1840 int transfer_id = 0;
1841 int server_type = 0; /* bt_server_type_t */
1843 bt_obex_server_transfer_info_t transfer_info;
1845 g_variant_get(parameters, "(i&s&s&s&stii)", &result, &file_name,
1846 &type, &device_name, &file_path, &size,
1847 &transfer_id, &server_type);
1849 /* Other server's event */
1850 ret_if(obex_server_id != server_type &&
1851 server_type != BT_FTP_SERVER);
1853 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1855 transfer_info.filename = g_strdup(file_name);
1856 transfer_info.type = g_strdup(type);
1857 transfer_info.device_name = g_strdup(device_name);
1858 transfer_info.file_path = g_strdup(file_path);
1859 transfer_info.file_size = size;
1860 transfer_info.transfer_id = transfer_id;
1861 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1862 FTP_SERVER : OPP_SERVER;
1864 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1865 result, &transfer_info,
1866 event_info->cb, event_info->user_data);
1868 g_free(transfer_info.filename);
1869 g_free(transfer_info.type);
1870 g_free(transfer_info.device_name);
1871 g_free(transfer_info.file_path);
1875 void __bt_pbap_client_event_filter(GDBusConnection *connection,
1876 const gchar *sender_name,
1877 const gchar *object_path,
1878 const gchar *interface_name,
1879 const gchar *signal_name,
1880 GVariant *parameters,
1883 bt_event_info_t *event_info;
1884 int result = BLUETOOTH_ERROR_NONE;
1885 event_info = (bt_event_info_t *)user_data;
1886 ret_if(event_info == NULL);
1888 if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
1890 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1893 ret_if(signal_name == NULL);
1894 BT_DBG("Type: %s", g_variant_get_type_string(parameters));
1895 if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
1896 bt_pbap_connected_t connected = { { { 0 }, }, };
1897 char *address = NULL;
1899 g_variant_get(parameters, "(is)", &result, &address);
1900 BT_DBG("address: %s", address);
1902 _bt_convert_addr_string_to_type(connected.btaddr.addr,
1905 connected.connected = 1;
1907 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
1909 event_info->cb, event_info->user_data);
1910 } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
1911 bt_pbap_connected_t connected = { { { 0 }, }, };
1912 char *address = NULL;
1914 g_variant_get(parameters, "(is)", &result, &address);
1915 BT_DBG("address: %s", address);
1917 _bt_convert_addr_string_to_type(connected.btaddr.addr,
1920 connected.connected = 0;
1922 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
1924 event_info->cb, event_info->user_data);
1925 } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
1926 bt_pbap_connected_t disconnected = { { { 0 }, }, };
1927 char *address = NULL;
1929 g_variant_get(parameters, "(is)", &result, &address);
1930 BT_DBG("address: %s", address);
1932 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
1934 disconnected.connected = 0;
1936 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
1937 result, &disconnected,
1938 event_info->cb, event_info->user_data);
1939 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
1940 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
1941 char *address = NULL;
1944 g_variant_get(parameters, "(isi)", &result, &address, &size);
1946 BT_DBG("address: %s", address);
1947 BT_DBG("size: %d", size);
1949 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
1951 pb_size.size = size;
1953 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
1955 event_info->cb, event_info->user_data);
1956 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
1957 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
1958 char *address = NULL;
1959 char *vcf_file = NULL;
1962 g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
1964 BT_DBG("address: %s", address);
1965 BT_DBG("vcf_file: %s", vcf_file);
1966 BT_DBG("success: %d", success);
1968 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
1970 pb_pull.vcf_file = vcf_file;
1971 pb_pull.success = success;
1972 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
1974 event_info->cb, event_info->user_data);
1975 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
1976 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
1977 char *address = NULL;
1979 gchar **list = NULL;
1980 GVariant *string_var;
1984 g_variant_get(parameters, "(isv)", &result, &address, &string_var);
1986 list = (gchar **)g_variant_get_strv(string_var, &count);
1989 BT_DBG("address: %s", address);
1990 BT_DBG("result: %d", result);
1991 BT_DBG("count: %d", count);
1992 for (i = 0; i < count; i++)
1993 BT_DBG("%s", list[i]);
1994 BT_DBG("success: %d", success);
1996 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
1998 vc_list.vcards = list;
1999 vc_list.length = count;
2000 vc_list.success = success;
2001 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2003 event_info->cb, event_info->user_data);
2005 g_variant_unref(string_var);
2007 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2008 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2009 char *address = NULL;
2010 char *vcf_file = NULL;
2013 g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
2015 BT_DBG("address: %s", address);
2016 BT_DBG("vcf_file: %s", vcf_file);
2017 BT_DBG("success: %d", success);
2019 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr,
2021 vc_pull.vcf_file = vcf_file;
2022 vc_pull.success = success;
2023 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2025 event_info->cb, event_info->user_data);
2026 } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2027 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2028 char *address = NULL;
2030 gchar **list = NULL;
2031 GVariant *string_var;
2035 g_variant_get(parameters, "(is@as)", &result, &address, &string_var);
2037 list = (gchar **)g_variant_get_strv(string_var, &count);
2039 BT_DBG("address: %s", address);
2040 for (i = 0; i < count; i++)
2041 BT_DBG("%s", list[i]);
2042 BT_DBG("success: %d", success);
2044 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2046 vc_list.vcards = list;
2047 vc_list.length = count;
2048 vc_list.success = success;
2049 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2051 event_info->cb, event_info->user_data);
2053 g_variant_unref(string_var);
2058 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2059 const gchar *sender_name,
2060 const gchar *object_path,
2061 const gchar *interface_name,
2062 const gchar *signal_name,
2063 GVariant *parameters,
2066 bt_event_info_t *event_info;
2067 int result = BLUETOOTH_ERROR_NONE;
2068 event_info = (bt_event_info_t *)user_data;
2069 ret_if(event_info == NULL);
2071 if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2073 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2076 ret_if(signal_name == NULL);
2078 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2079 const char *address = NULL;
2080 const char *uuid = NULL;
2082 bluetooth_rfcomm_connection_t conn_info;
2084 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2087 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2088 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2089 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2090 conn_info.socket_fd = socket_fd;
2091 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2094 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2096 event_info->cb, event_info->user_data);
2097 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2098 const char *address = NULL;
2099 const char *uuid = NULL;
2101 bluetooth_rfcomm_disconnection_t disconn_info;
2103 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2106 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2107 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2108 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2109 disconn_info.socket_fd = socket_fd;
2110 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2113 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2114 result, &disconn_info,
2115 event_info->cb, event_info->user_data);
2116 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2120 bluetooth_rfcomm_received_data_t data_r;
2123 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2126 buffer_len = g_variant_get_size(byte_var);
2127 buffer = (char *) g_variant_get_data(byte_var);
2129 data_r.socket_fd = socket_fd;
2130 data_r.buffer_size = buffer_len;
2131 data_r.buffer = buffer;
2133 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2135 event_info->cb, event_info->user_data);
2136 g_variant_unref(byte_var);
2140 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2141 const gchar *sender_name,
2142 const gchar *object_path,
2143 const gchar *interface_name,
2144 const gchar *signal_name,
2145 GVariant *parameters,
2148 bt_event_info_t *event_info;
2149 int result = BLUETOOTH_ERROR_NONE;
2150 event_info = (bt_event_info_t *)user_data;
2151 ret_if(event_info == NULL);
2153 if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2155 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2158 ret_if(signal_name == NULL);
2160 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2161 const char *address = NULL;
2162 const char *uuid = NULL;
2164 bluetooth_rfcomm_connection_t conn_info;
2166 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2169 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2170 conn_info.device_role = RFCOMM_ROLE_SERVER;
2171 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2172 conn_info.socket_fd = socket_fd;
2173 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2176 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2178 event_info->cb, event_info->user_data);
2179 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2180 const char *address = NULL;
2181 const char *uuid = NULL;
2183 bluetooth_rfcomm_disconnection_t disconn_info;
2185 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2188 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2189 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2190 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2191 disconn_info.socket_fd = socket_fd;
2192 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2195 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2196 result, &disconn_info,
2197 event_info->cb, event_info->user_data);
2198 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2199 /* OSP only event */
2200 bluetooth_rfcomm_connection_request_t req_ind;
2201 char *address = NULL;
2207 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2208 &uuid, &name, &path, &socket_fd);
2210 if (_check_uuid_path(path, uuid) == FALSE)
2213 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2214 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2217 req_ind.socket_fd = socket_fd;
2219 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2221 event_info->cb, event_info->user_data);
2222 } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2223 /* OSP only event */
2226 g_variant_get(parameters, "(in)", &result, &socket_fd);
2228 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2230 _bt_remove_server(socket_fd);
2231 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2232 char *buffer = NULL;
2235 bluetooth_rfcomm_received_data_t data_r;
2238 g_variant_get(parameters, "(in@ay)", &result,
2239 &socket_fd, &byte_var);
2241 buffer_len = g_variant_get_size(byte_var);
2242 buffer = (char *) g_variant_get_data(byte_var);
2244 data_r.socket_fd = socket_fd;
2245 data_r.buffer_size = buffer_len;
2246 data_r.buffer = buffer;
2248 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2250 event_info->cb, event_info->user_data);
2251 g_variant_unref(byte_var);
2255 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2256 const gchar *sender_name,
2257 const gchar *object_path,
2258 const gchar *interface_name,
2259 const gchar *signal_name,
2260 GVariant *parameters,
2265 bt_event_info_t *event_info;
2266 int result = BLUETOOTH_ERROR_NONE;
2267 event_info = (bt_event_info_t *)user_data;
2268 ret_if(event_info == NULL);
2271 if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2273 if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2276 ret_if(signal_name == NULL);
2278 BT_DBG("%s", signal_name);
2279 if (strcasecmp(signal_name, "Connected") == 0) {
2280 char *address = NULL;
2282 g_variant_get(parameters, "(s)", &address);
2283 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2285 event_info->cb, event_info->user_data);
2286 } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2287 char *address = NULL;
2289 g_variant_get(parameters, "(s)", &address);
2290 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2292 event_info->cb, event_info->user_data);
2293 } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2294 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2296 event_info->cb, event_info->user_data);
2297 } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2298 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2300 event_info->cb, event_info->user_data);
2301 } else if (strcasecmp(signal_name, "Ring") == 0) {
2302 char *phoneno = NULL;
2304 g_variant_get(parameters, "(&s)", &phoneno);
2306 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2308 event_info->cb, event_info->user_data);
2309 } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2310 char *phoneno = NULL;
2312 g_variant_get(parameters, "(&s)", &phoneno);
2314 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2316 event_info->cb, event_info->user_data);
2317 } else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2318 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2320 event_info->cb, event_info->user_data);
2321 } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2322 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2324 event_info->cb, event_info->user_data);
2325 } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2326 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2328 event_info->cb, event_info->user_data);
2329 } else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2330 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2332 event_info->cb, event_info->user_data);
2333 } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2334 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2336 event_info->cb, event_info->user_data);
2337 } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2338 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2340 event_info->cb, event_info->user_data);
2341 } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2343 GVariant *var_data = NULL;
2344 char *number = NULL;
2345 int idx, dir, status, mpart;
2346 bt_hf_call_list_s *handle = NULL;
2348 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2350 BT_DBG("call count : %d", call_count);
2353 GVariantIter *iter = NULL;
2354 __bt_call_list_create(&handle);
2356 g_variant_get(var_data, "a(siiii)", &iter);
2357 while (g_variant_iter_loop(iter, "(siiii)", &number,
2358 &dir, &status, &mpart, &idx)) {
2359 BT_DBG("call number:%s, dir:%d, status : %d",
2360 number, dir, status);
2361 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2362 __bt_call_list_add(handle, number, dir,
2363 status, mpart, idx);
2365 g_variant_iter_free(iter);
2366 g_variant_unref(var_data);
2369 if (handle && (call_count == g_list_length(handle->list))) {
2370 handle->count = call_count;
2371 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2373 event_info->cb, event_info->user_data);
2375 BT_ERR(" Mismatch in call count : %d", call_count);
2378 __bt_call_list_destroy(handle);
2379 } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2381 g_variant_get(parameters, "(i)", &status);
2382 BT_DBG("status = [%d]\n", status);
2384 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2386 event_info->cb, event_info->user_data);
2388 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2390 event_info->cb, event_info->user_data);
2391 } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2393 g_variant_get(parameters, "(i)", &value);
2394 BT_DBG("Value = [%d]\n", value);
2395 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2397 event_info->cb, event_info->user_data);
2398 } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2401 bluetooth_vendor_dep_at_cmd_t cmd;
2402 g_variant_get(parameters, "(i&s)", &value, &msg);
2403 BT_DBG("Value = [%d], message = %s\n", value, msg);
2406 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2408 event_info->cb, event_info->user_data);
2413 static void __bt_remove_all_events(void)
2416 bt_event_info_t *info;
2418 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2422 _bt_unregister_event(info->event_type);
2425 g_slist_free(event_list);
2429 static gboolean __bt_event_is_registered(int event_type)
2432 bt_event_info_t *info;
2434 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2439 if (info->event_type == event_type)
2446 bt_event_info_t *_bt_event_get_cb_data(int event_type)
2449 bt_event_info_t *info;
2451 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2456 if (info->event_type == event_type)
2463 void _bt_add_server(int server_fd)
2465 bt_server_info_t *info;
2467 info = g_new0(bt_server_info_t, 1);
2468 info->server_fd = server_fd;
2470 server_list = g_slist_append(server_list, info);
2473 void _bt_remove_server(int server_fd)
2476 bt_server_info_t *info;
2478 for (l = server_list; l != NULL; l = g_slist_next(l)) {
2483 if (info->server_fd == server_fd) {
2484 server_list = g_slist_remove(server_list, (void *)info);
2491 void _bt_set_obex_server_id(int server_type)
2493 obex_server_id = server_type;
2496 int _bt_get_obex_server_id(void)
2498 return obex_server_id;
2501 int _bt_init_event_handler(void)
2503 if (is_initialized == TRUE) {
2504 BT_ERR("Connection already exist");
2505 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2508 __bt_remove_all_events();
2510 is_initialized = TRUE;
2512 return BLUETOOTH_ERROR_NONE;
2515 int _bt_deinit_event_handler(void)
2517 if (is_initialized == FALSE) {
2518 BT_ERR("Connection dose not exist");
2519 return BLUETOOTH_ERROR_INTERNAL;
2522 __bt_remove_all_events();
2524 if (disable_timer_id > 0) {
2525 g_source_remove(disable_timer_id);
2526 disable_timer_id = 0;
2529 is_initialized = FALSE;
2531 return BLUETOOTH_ERROR_NONE;
2534 static void __bt_event_data_free(void *data)
2536 bt_event_info_t *cb_data = data;
2538 ret_if(cb_data == NULL);
2543 int _bt_register_event(int event_type, void *event_cb, void *user_data)
2545 GDBusConnection *connection_type;
2546 GDBusSignalCallback event_func;
2547 bt_event_info_t *cb_data;
2549 const char *interface = BT_EVENT_SERVICE;
2551 if (is_initialized == FALSE)
2552 _bt_init_event_handler();
2554 if (__bt_event_is_registered(event_type) == TRUE) {
2555 BT_ERR("The event is already registed");
2556 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2559 switch (event_type) {
2560 case BT_ADAPTER_EVENT:
2561 event_func = __bt_adapter_event_filter;
2562 path = BT_ADAPTER_PATH;
2564 case BT_LE_ADAPTER_EVENT:
2565 event_func = __bt_adapter_le_event_filter;
2566 path = BT_LE_ADAPTER_PATH;
2568 case BT_DEVICE_EVENT:
2569 event_func = __bt_device_event_filter;
2570 path = BT_DEVICE_PATH;
2573 event_func = __bt_hid_event_filter;
2576 case BT_HEADSET_EVENT:
2577 event_func = __bt_headset_event_filter;
2578 path = BT_HEADSET_PATH;
2580 case BT_NETWORK_EVENT:
2581 event_func = __bt_network_event_filter;
2582 path = BT_NETWORK_PATH;
2584 case BT_AVRCP_EVENT:
2585 event_func = __bt_avrcp_event_filter;
2586 path = BT_AVRCP_PATH;
2588 case BT_AVRCP_CONTROL_EVENT:
2589 event_func = __bt_avrcp_control_event_filter;
2590 path = BT_AVRCP_CONTROL_PATH;
2592 case BT_OPP_CLIENT_EVENT:
2593 event_func = __bt_opp_client_event_filter;
2594 path = BT_OPP_CLIENT_PATH;
2596 case BT_OPP_SERVER_EVENT:
2597 event_func = __bt_opp_server_event_filter;
2598 path = BT_OPP_SERVER_PATH;
2600 case BT_PBAP_CLIENT_EVENT:
2601 event_func = __bt_pbap_client_event_filter;
2602 path = BT_PBAP_CLIENT_PATH;
2604 case BT_RFCOMM_CLIENT_EVENT:
2605 event_func = __bt_rfcomm_client_event_filter;
2606 path = BT_RFCOMM_CLIENT_PATH;
2608 case BT_RFCOMM_SERVER_EVENT:
2609 event_func = __bt_rfcomm_server_event_filter;
2610 path = BT_RFCOMM_SERVER_PATH;
2612 case BT_HF_AGENT_EVENT:
2613 BT_DBG("BT_HF_AGENT_EVENT\n");
2614 event_func = __bt_hf_agent_event_filter;
2615 path = BT_HF_AGENT_PATH;
2616 interface = BT_HF_SERVICE_INTERFACE;
2618 case BT_A2DP_SOURCE_EVENT:
2619 BT_DBG("BT_A2DP_SOURCE_EVENT");
2620 event_func = __bt_a2dp_source_event_filter;
2621 path = BT_A2DP_SOURCE_PATH;
2623 case BT_HID_DEVICE_EVENT:
2624 BT_DBG("BT_HID_DEVICE_EVENT");
2625 event_func = __bt_hid_device_event_filter;
2626 path = BT_HID_DEVICE_PATH;
2628 #ifdef GATT_NO_RELAY
2629 case BT_GATT_BLUEZ_EVENT:
2630 BT_DBG("BT_GATT_BLUEZ_EVENT");
2631 event_func = __bt_device_event_filter;
2632 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2637 BT_ERR("Unknown event");
2638 return BLUETOOTH_ERROR_INTERNAL;
2641 connection_type = _bt_gdbus_get_system_gconn();
2642 if (connection_type == NULL)
2643 return BLUETOOTH_ERROR_INTERNAL;
2645 cb_data = g_new0(bt_event_info_t, 1);
2647 cb_data->event_type = event_type;
2648 cb_data->cb = event_cb;
2649 cb_data->user_data = user_data;
2651 cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2652 NULL, interface, NULL, path, NULL, 0,
2653 event_func, cb_data, NULL);
2655 event_list = g_slist_append(event_list, cb_data);
2657 return BLUETOOTH_ERROR_NONE;
2660 int _bt_unregister_event(int event_type)
2662 GDBusConnection *connection_type;
2663 bt_event_info_t *cb_data;
2665 if (is_initialized == FALSE) {
2666 BT_ERR("Event is not registered");
2667 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2670 if (__bt_event_is_registered(event_type) == FALSE) {
2671 BT_ERR("Not registered event");
2672 return BLUETOOTH_ERROR_INTERNAL;
2675 cb_data = _bt_event_get_cb_data(event_type);
2677 if (cb_data == NULL) {
2678 BT_ERR("No matched event data");
2679 return BLUETOOTH_ERROR_INTERNAL;
2682 connection_type = _bt_gdbus_get_system_gconn();
2684 event_list = g_slist_remove(event_list, (void *)cb_data);
2686 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2688 g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2690 __bt_event_data_free((void *)cb_data);
2692 return BLUETOOTH_ERROR_NONE;
2695 static void __bt_name_owner_changed(GDBusConnection *connection,
2696 const gchar *sender_name,
2697 const gchar *object_path,
2698 const gchar *interface_name,
2699 const gchar *signal_name,
2700 GVariant *parameters,
2703 const char *name = NULL;
2704 const char *old_owner = NULL;
2705 const char *new_owner = NULL;
2706 bt_event_info_t *event_info;
2708 g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2710 if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2711 (new_owner != NULL && *new_owner == '\0')) {
2712 BT_DBG("bt-service is terminated");
2713 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2714 if (event_info == NULL)
2717 if (disable_timer_id > 0)
2718 g_source_remove(disable_timer_id);
2720 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2721 (GSourceFunc)__bt_reliable_disable_cb,
2726 void _bt_register_name_owner_changed(void)
2728 GDBusConnection *connection_type;
2730 connection_type = _bt_gdbus_get_system_gconn();
2731 if (connection_type == NULL) {
2732 BT_ERR("Unable to get the bus");
2735 owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2736 NULL, DBUS_INTERFACE_DBUS,
2737 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2738 __bt_name_owner_changed, NULL, NULL);
2741 void _bt_unregister_name_owner_changed(void)
2743 GDBusConnection *connection_type;
2745 connection_type = _bt_gdbus_get_system_gconn();
2746 if (connection_type != NULL && owner_sig_id != -1) {
2747 g_dbus_connection_signal_unsubscribe(connection_type,