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.
23 #include "bluetooth-api.h"
24 #include "bluetooth-audio-api.h"
25 #include "bluetooth-hid-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-gatt-client.h"
32 #include "bt-request-sender.h"
34 #define PROFILE_SUPPORTED 0x3 /* This corresponds to binary 0b11*/
35 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
45 static int obex_server_id;
46 static guint disable_timer_id;
47 static gboolean is_initialized;
48 static GSList *sending_list = NULL;
49 static GSList *server_list = NULL;
50 static GSList *event_list = NULL;
51 static int owner_sig_id = -1;
53 void _bt_add_push_request_id(int request_id)
55 bt_sending_info_t *info;
57 info = g_new0(bt_sending_info_t, 1);
58 info->request_id = request_id;
60 sending_list = g_slist_append(sending_list, info);
63 static gboolean __bt_is_request_id_exist(int request_id)
66 bt_sending_info_t *info;
68 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
73 BT_DBG("compare %d with %d", info->request_id, request_id);
74 if (info->request_id == request_id)
81 static void __bt_remove_push_request_id(int request_id)
84 bt_sending_info_t *info;
86 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
91 BT_DBG("info->request_id = %d\n", info->request_id);
92 BT_DBG("request_id = %d\n", request_id);
93 if (info->request_id == request_id) {
94 sending_list = g_slist_remove(sending_list, (void *)info);
101 static void __bt_remove_all_push_request_id(void)
104 bt_sending_info_t *info;
106 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
111 g_slist_free(sending_list);
115 static void __bt_remove_all_server(void)
118 bt_server_info_t *info;
120 for (l = server_list; l != NULL; l = g_slist_next(l)) {
125 g_slist_free(server_list);
129 static gboolean __bt_is_server_exist(int server_fd)
132 bt_server_info_t *info;
134 for (l = server_list; l != NULL; l = g_slist_next(l)) {
139 retv_if(info->server_fd == server_fd, TRUE);
145 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
152 ret_if(dev_info == NULL);
153 ret_if(uuids == NULL);
154 ret_if(uuid_count <= 0);
156 dev_info->service_index = uuid_count;
158 for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
159 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
161 parts = g_strsplit(uuids[i], "-", -1);
163 if (parts == NULL || parts[0] == NULL) {
168 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
172 static int __bt_call_list_create(bt_hf_call_list_s **list)
174 bt_hf_call_list_s *handle;
177 BT_DBG("Already Initialized");
178 return BLUETOOTH_ERROR_NONE;
180 handle = g_malloc0(sizeof(bt_hf_call_list_s));
182 return BLUETOOTH_ERROR_NONE;
185 static int __bt_call_list_reset(bt_hf_call_list_s *list)
187 bt_hf_call_list_s *handle;
188 bt_hf_call_status_info_t *call_status;
191 BT_ERR("invalid parameter");
192 return BLUETOOTH_ERROR_INVALID_PARAM;
194 handle = (bt_hf_call_list_s *)list;
196 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(handle->list, 0);
197 if (call_status == NULL)
199 handle->list = g_list_remove(handle->list, call_status);
200 g_free(call_status->number);
203 return BLUETOOTH_ERROR_NONE;
206 static int __bt_call_list_destroy(bt_hf_call_list_s *list)
209 bt_hf_call_list_s *handle;
212 BT_ERR("invalid parameter");
213 return BLUETOOTH_ERROR_INVALID_PARAM;
215 handle = (bt_hf_call_list_s *)list;
216 result = __bt_call_list_reset(list);
220 static int __bt_call_list_add(bt_hf_call_list_s *list, char * number,
221 int dir, int status, int mpart, int idx)
223 bt_hf_call_list_s *handle;
224 bt_hf_call_status_info_t *call_status;
227 BT_ERR("invalid parameter");
228 return BLUETOOTH_ERROR_INVALID_PARAM;
230 handle = (bt_hf_call_list_s *)list;
231 call_status = g_malloc0(sizeof(bt_hf_call_status_info_t));
232 call_status->number = g_strdup(number);
233 call_status->direction = dir;
234 call_status->status = status;
235 call_status->mpart = mpart;
236 call_status->idx = idx;
237 handle->list = g_list_append(handle->list, (gpointer)call_status);
238 return BLUETOOTH_ERROR_NONE;
241 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
243 bluetooth_device_info_t *dev_info;
244 const char *address = NULL;
245 const char *name = NULL;
246 gchar **uuids = NULL;
247 unsigned int dev_class = 0;
249 gboolean paired = FALSE;
251 gboolean trust = FALSE;
253 int result = BLUETOOTH_ERROR_NONE;
254 GVariant *string_var;
256 int manufacturer_data_len = 0;
257 GVariant *manufacturer_var = NULL;
258 const char *manufacturer_data = NULL;
260 g_variant_get(parameters, "(isunsbub@asn@ay)", &result, &address,
261 &dev_class, &rssi, &name, &paired,
262 &connected, &trust, &string_var, &manufacturer_data_len, &manufacturer_var);
264 if (string_var == NULL) {
265 BT_ERR("invalid parameters in signal");
269 uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
271 len = g_variant_get_size(manufacturer_var);
273 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
275 dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
276 dev_info->rssi = rssi;
277 dev_info->paired = paired;
278 dev_info->connected = connected;
279 dev_info->trust = trust;
281 g_strlcpy(dev_info->device_name.name, name,
282 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
284 _bt_divide_device_class(&dev_info->device_class, dev_class);
286 _bt_convert_addr_string_to_type(dev_info->device_address.addr,
290 __bt_get_uuid_info(dev_info, uuids, uuid_count);
292 if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
293 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
294 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
296 dev_info->manufacturer_data.data_len = manufacturer_data_len;
297 if (manufacturer_data)
298 for (i = 0; i < manufacturer_data_len; i++)
299 dev_info->manufacturer_data.data[i] = manufacturer_data[i];
302 g_variant_unref(string_var);
303 g_variant_unref(manufacturer_var);
307 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
309 bluetooth_le_device_info_t *le_dev_info;
310 const char *address = NULL;
315 int adv_data_len = 0;
316 GVariant *adv_var = NULL;
317 const char *adv_data = NULL;
318 int scan_data_len = 0;
319 GVariant *scan_var = NULL;
320 const char *scan_data = NULL;
321 int result = BLUETOOTH_ERROR_NONE;
323 g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
324 &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
326 len = g_variant_get_size(adv_var);
328 adv_data = (char *)g_variant_get_data(adv_var);
330 len = g_variant_get_size(scan_var);
332 scan_data = (char *)g_variant_get_data(scan_var);
334 le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
335 _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
336 le_dev_info->addr_type = addr_type;
337 le_dev_info->rssi = rssi;
338 le_dev_info->adv_ind_data.data_len = adv_data_len;
340 for (i = 0; i < adv_data_len; i++)
342 le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
344 le_dev_info->scan_resp_data.data_len = scan_data_len;
346 for (i = 0; i < scan_data_len; i++)
348 le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
351 g_variant_unref(adv_var);
352 g_variant_unref(scan_var);
356 gboolean __bt_reliable_disable_cb(gpointer user_data)
359 bt_event_info_t *event_info = user_data;
361 _bt_set_le_scan_status(FALSE);
363 _bt_set_adapter_internal_status(FALSE);
365 if (is_initialized != FALSE) {
366 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
367 BLUETOOTH_ERROR_NONE, NULL,
368 event_info->cb, event_info->user_data);
371 obex_server_id = BT_NO_SERVER;
372 __bt_remove_all_server();
373 __bt_remove_all_push_request_id();
374 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
375 _bt_rfcomm_server_free_all();
378 _bluetooth_hid_free_hid_info();
384 void __bt_adapter_event_filter(GDBusConnection *connection,
385 const gchar *sender_name,
386 const gchar *object_path,
387 const gchar *interface_name,
388 const gchar *signal_name,
389 GVariant *parameters,
392 bt_event_info_t *event_info;
393 int result = BLUETOOTH_ERROR_NONE;
395 event_info = (bt_event_info_t *)user_data;
396 ret_if(event_info == NULL);
398 if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
400 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
403 if (strcasecmp(signal_name, BT_ENABLED) == 0) {
404 BT_INFO("BT_ENABLED");
405 g_variant_get(parameters, "(i)", &result);
407 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
409 event_info->cb, event_info->user_data);
410 } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
411 BT_INFO("BT_DISABLED");
413 /* Wait for the termining time of bt-service */
414 if (disable_timer_id > 0)
415 g_source_remove(disable_timer_id);
417 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
418 (GSourceFunc)__bt_reliable_disable_cb,
420 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
423 g_variant_get(parameters, "(in)", &result, &mode);
424 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
426 event_info->cb, event_info->user_data);
427 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
430 g_variant_get(parameters, "(in)", &result, &timeout);
431 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
433 event_info->cb, event_info->user_data);
434 } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
435 gboolean connectable = FALSE;
437 g_variant_get(parameters, "(b)", &connectable);
438 BT_DBG("Connectable is changed : %d", connectable);
440 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
441 result, &connectable,
442 event_info->cb, event_info->user_data);
443 } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
444 char *adapter_name = NULL;
446 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
447 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
448 result, adapter_name,
449 event_info->cb, event_info->user_data);
450 } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
451 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
452 BLUETOOTH_ERROR_NONE, NULL,
453 event_info->cb, event_info->user_data);
454 } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
455 g_variant_get(parameters, "(i)", &result);
456 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
458 event_info->cb, event_info->user_data);
459 } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
462 g_variant_get(parameters, "(ii)", &result, &adv_handle);
463 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
465 event_info->cb, event_info->user_data);
466 } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
469 g_variant_get(parameters, "(ii)", &result, &adv_handle);
470 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
472 event_info->cb, event_info->user_data);
473 } else if (strcasecmp(signal_name, BT_ADVERTISING_MANUFACTURER_DATA_CHANGED) == 0) {
474 GVariant *var = NULL;
478 g_variant_get(parameters, "(@ay)", &var);
479 len = g_variant_get_size(var);
480 data = (char *)g_variant_get_data(var);
482 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
484 event_info->cb, event_info->user_data);
486 g_variant_unref(var);
487 } else if (strcasecmp(signal_name, BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
488 GVariant *var = NULL;
492 g_variant_get(parameters, "(@ay)", &var);
493 len = g_variant_get_size(var);
494 data = (char *)g_variant_get_data(var);
496 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
498 event_info->cb, event_info->user_data);
500 g_variant_unref(var);
501 } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
502 GVariant *var = NULL;
506 g_variant_get(parameters, "(@ay)", &var);
507 len = g_variant_get_size(var);
508 data = (char *)g_variant_get_data(var);
510 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
512 event_info->cb, event_info->user_data);
514 g_variant_unref(var);
515 } else if (strcasecmp(signal_name, BT_PASSKEY_NOTIFICATION) == 0) {
516 const char *address = NULL;
517 const char *passkey = NULL;
518 const char *passkey_info[2];
520 g_variant_get(parameters, "(&s&s)", &address, &passkey);
521 passkey_info[0] = address;
522 passkey_info[1] = passkey;
524 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_NOTIFICATION,
525 BLUETOOTH_ERROR_NONE, (void*)passkey_info,
526 event_info->cb, event_info->user_data);
527 } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
529 bluetooth_device_info_t *device_info;
531 device_info = __bt_get_device_info_in_message(parameters,
533 ret_if(device_info == NULL);
535 if (strlen(device_info->device_name.name) > 0)
536 event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
538 event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
540 _bt_common_event_cb(event,
542 event_info->cb, event_info->user_data);
545 } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
546 bluetooth_device_info_t *device_info;
548 device_info = __bt_get_device_info_in_message(parameters,
550 ret_if(device_info == NULL);
552 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
554 event_info->cb, event_info->user_data);
557 } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
558 const char *address = NULL;
559 bluetooth_device_address_t dev_address = { {0} };
561 g_variant_get(parameters, "(i&s)", &result, &address);
563 _bt_convert_addr_string_to_type(dev_address.addr,
566 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
567 result, &dev_address,
568 event_info->cb, event_info->user_data);
569 } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
570 bluetooth_device_info_t *device_info;
571 bt_sdp_info_t sdp_info;
573 device_info = __bt_get_device_info_in_message(parameters,
575 ret_if(device_info == NULL);
577 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
579 sdp_info.service_index = device_info->service_index;
581 memcpy(&sdp_info.device_addr,
582 &device_info->device_address,
583 BLUETOOTH_ADDRESS_LENGTH);
585 memcpy(sdp_info.service_list_array,
586 device_info->service_list_array,
587 BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
589 memcpy(sdp_info.uuids,
591 BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
593 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
595 event_info->cb, event_info->user_data);
598 } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
599 gboolean ipsp_intialized = FALSE;
600 g_variant_get(parameters, "(b)", &ipsp_intialized);
602 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
604 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
605 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
606 event_info->cb, event_info->user_data);
607 } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
608 const char *address = NULL;
609 const char *name = NULL;
610 const char *str_passkey = NULL;
612 bluetooth_authentication_request_info_t auth_info;
613 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
615 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
617 g_strlcpy(auth_info.device_name.name, name,
618 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
619 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
621 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
623 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
625 event_info->cb, event_info->user_data);
626 } else if (strcasecmp(signal_name, BT_PIN_REQ_RECEIVED) == 0) {
627 const char *address = NULL;
628 const char *name = NULL;
630 bluetooth_authentication_request_info_t auth_info;
631 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
633 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
635 g_strlcpy(auth_info.device_name.name, name,
636 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
637 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
640 _bt_common_event_cb(BLUETOOTH_EVENT_PIN_REQUEST,
642 event_info->cb, event_info->user_data);
643 } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
644 const char *address = NULL;
645 const char *name = NULL;
647 bluetooth_authentication_request_info_t auth_info;
648 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
650 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
652 g_strlcpy(auth_info.device_name.name, name,
653 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
654 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
657 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
659 event_info->cb, event_info->user_data);
660 } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
661 const char *address = NULL;
662 const char *name = NULL;
663 const char *str_passkey = NULL;
665 bluetooth_authentication_request_info_t auth_info;
666 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
668 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
670 g_strlcpy(auth_info.device_name.name, name,
671 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
672 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
674 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
676 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
678 event_info->cb, event_info->user_data);
682 void __bt_adapter_le_event_filter(GDBusConnection *connection,
683 const gchar *sender_name,
684 const gchar *object_path,
685 const gchar *interface_name,
686 const gchar *signal_name,
687 GVariant *parameters,
690 bt_event_info_t *event_info;
691 int result = BLUETOOTH_ERROR_NONE;
693 event_info = (bt_event_info_t *)user_data;
694 ret_if(event_info == NULL);
696 if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
698 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
701 if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
702 BT_INFO("BT_LE_ENABLED");
703 g_variant_get(parameters, "(i)", &result);
704 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
706 event_info->cb, event_info->user_data);
707 } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
708 BT_INFO("BT_LE_DISABLED");
709 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
711 event_info->cb, event_info->user_data);
712 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
713 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
714 BLUETOOTH_ERROR_NONE, NULL,
715 event_info->cb, event_info->user_data);
716 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
717 g_variant_get(parameters, "(i)", &result);
718 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
720 event_info->cb, event_info->user_data);
721 } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
722 bluetooth_le_device_info_t *le_device_info;
724 le_device_info = __bt_get_le_device_info_in_message(parameters,
726 ret_if(le_device_info == NULL);
728 if (bluetooth_is_le_scanning() == TRUE) {
729 _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
730 result, le_device_info,
731 event_info->cb, event_info->user_data);
734 g_free(le_device_info);
738 void __bt_device_event_filter(GDBusConnection *connection,
739 const gchar *sender_name,
740 const gchar *object_path,
741 const gchar *interface_name,
742 const gchar *signal_name,
743 GVariant *parameters,
746 bt_event_info_t *event_info;
747 int result = BLUETOOTH_ERROR_NONE;
749 event_info = (bt_event_info_t *)user_data;
750 ret_if(event_info == NULL);
752 gboolean gatt_interface = FALSE;
754 if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
755 gatt_interface = TRUE;
757 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
758 gatt_interface == FALSE)
760 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
761 gatt_interface == FALSE)
764 ret_if(signal_name == NULL);
766 if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
767 const char *address = NULL;
768 bluetooth_device_address_t dev_address = { {0} };
769 BT_DBG("BT_GATT_CONNECTED");
770 g_variant_get(parameters, "(i&s)", &result, &address);
772 _bt_convert_addr_string_to_type(dev_address.addr, address);
773 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
774 result, &dev_address,
775 event_info->cb, event_info->user_data);
776 } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
777 const char *address = NULL;
778 bluetooth_device_address_t dev_address = { {0} };
779 BT_DBG("BT_GATT_DISCONNECTED");
780 g_variant_get(parameters, "(i&s)", &result, &address);
782 _bt_convert_addr_string_to_type(dev_address.addr, address);
783 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
784 result, &dev_address,
785 event_info->cb, event_info->user_data);
786 } else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
787 const char *address = NULL;
788 bluetooth_device_address_t dev_address = { {0} };
789 bluetooth_le_att_mtu_info_t att_mtu_info;
792 BT_DBG("BT_GATT_REQ_ATT_MTU_CHANGED");
793 g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
795 _bt_convert_addr_string_to_type(dev_address.addr, address);
797 memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
798 memcpy(att_mtu_info.device_address.addr,
800 BLUETOOTH_ADDRESS_LENGTH);
802 att_mtu_info.mtu = mtu;
803 att_mtu_info.status = status;
805 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
806 result, &att_mtu_info,
807 event_info->cb, event_info->user_data);
808 } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
809 const char *char_handle = NULL;
811 const char * value = NULL;
812 GVariant *char_value_var = NULL;
813 bt_gatt_char_value_t char_val = { 0, };
815 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
817 len = g_variant_get_size(char_value_var);
818 ret_if(char_value_var == NULL);
821 value = (char *)g_variant_get_data(char_value_var);
823 char_val.char_handle = g_strdup(char_handle);
824 char_val.val_len = len;
825 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
826 if (char_val.val_len > 0 && value != NULL) {
827 char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
828 memcpy(char_val.char_value, value, len);
829 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
831 event_info->cb, event_info->user_data);
832 g_free(char_val.char_value);
833 g_variant_unref(char_value_var);
835 g_free(char_val.char_handle);
836 } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
837 const char *address = NULL;
838 unsigned char addr_type;
839 bt_connection_info_t conn_info;
840 bluetooth_device_address_t dev_address = { {0} };
841 BT_DBG("BT_DEVICE_CONNECTED");
842 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
844 _bt_convert_addr_string_to_type(dev_address.addr,
847 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
849 memcpy(conn_info.device_addr.addr,
851 BLUETOOTH_ADDRESS_LENGTH);
853 conn_info.addr_type = addr_type;
854 conn_info.disc_reason = 0;
855 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
857 event_info->cb, event_info->user_data);
859 } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
860 const char *address = NULL;
861 unsigned char addr_type;
862 bt_connection_info_t conn_info;
863 bluetooth_device_address_t dev_address = { {0} };
864 BT_DBG("BT_DEVICE_DISCONNECTED");
865 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
867 _bt_convert_addr_string_to_type(dev_address.addr,
870 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
872 memcpy(conn_info.device_addr.addr,
874 BLUETOOTH_ADDRESS_LENGTH);
876 conn_info.addr_type = addr_type;
877 conn_info.disc_reason = result;
878 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
880 event_info->cb, event_info->user_data);
882 } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
883 bt_rssi_enabled_t enabled = { 0, };
886 gboolean rssi_enabled = FALSE;
888 g_variant_get(parameters, "(isib)", &result, &address,
889 &link_type, &rssi_enabled);
891 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
892 address, link_type, rssi_enabled);
893 enabled.address = address;
894 enabled.link_type = link_type;
895 enabled.rssi_enabled = rssi_enabled;
897 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
899 event_info->cb, event_info->user_data);
900 } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
905 bt_rssi_alert_t alert = { 0, };
907 g_variant_get(parameters, "(isiii)", &result, &address,
908 &link_type, &alert_type, &rssi_dbm);
910 alert.alert_type = alert_type;
911 alert.rssi_dbm = rssi_dbm;
912 alert.address = address;
913 alert.link_type = link_type;
914 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
915 address, link_type, alert_type, rssi_dbm);
916 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
918 event_info->cb, event_info->user_data);
919 } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
923 bt_raw_rssi_t raw_rssi = { 0, };
925 g_variant_get(parameters, "(isii)", &result,
926 &address, &link_type, &rssi_dbm);
928 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
929 address, link_type, rssi_dbm);
931 raw_rssi.rssi_dbm = rssi_dbm;
932 raw_rssi.address = address;
933 raw_rssi.link_type = link_type;
935 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
937 event_info->cb, event_info->user_data);
938 } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
939 const char *address = NULL;
940 bluetooth_device_address_t dev_address = { {0} };
942 g_variant_get(parameters, "(i&s)", &result, &address);
944 _bt_convert_addr_string_to_type(dev_address.addr,
947 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
948 result, &dev_address,
949 event_info->cb, event_info->user_data);
950 } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
951 const char *address = NULL;
952 bluetooth_device_address_t dev_address = { {0} };
954 g_variant_get(parameters, "(i&s)", &result, &address);
956 _bt_convert_addr_string_to_type(dev_address.addr,
959 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
960 result, &dev_address,
961 event_info->cb, event_info->user_data);
962 } else if (strcasecmp(signal_name, BT_SUPPORTED_PROFILE_TRUSTED) == 0) {
964 bt_supported_profile_trusted_t profile_info = { 0, };
967 g_variant_get(parameters, "(i&si)", &result,
970 BT_DBG("Address [%s] trust[%d]", address, trust);
971 profile_info.address = address;
972 if (trust & (PROFILE_SUPPORTED << 0)) { /* Bit 0 & 1 - for PBAP Supported */
973 profile_info.profile = TRUSTED_PROFILE_PBAP;
974 profile_info.supported = TRUE;
975 if (trust & (1 << 1)) /* Bit 1 - for PBAP Trusted */
976 profile_info.trusted = TRUE;
978 profile_info.trusted = FALSE;
980 _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
981 result, &profile_info,
982 event_info->cb, event_info->user_data);
984 if (trust & (PROFILE_SUPPORTED << 2)) { /* Bit 2 & 3 - for MAP Supported */
985 profile_info.profile = TRUSTED_PROFILE_MAP;
986 profile_info.supported = TRUE;
987 if (trust & (1 << 3)) /* Bit 3 - for PBAP Trusted */
988 profile_info.trusted = TRUE;
990 profile_info.trusted = FALSE;
992 _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
993 result, &profile_info,
994 event_info->cb, event_info->user_data);
996 if (trust & (PROFILE_SUPPORTED << 4)) { /* Bit 4 & 5- for SAP Supported */
997 profile_info.profile = TRUSTED_PROFILE_SAP;
998 profile_info.supported = TRUE;
999 if (trust & (1 << 5)) /* Bit 5 - for SAP Trusted */
1000 profile_info.trusted = TRUE;
1002 profile_info.trusted = FALSE;
1004 _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1005 result, &profile_info,
1006 event_info->cb, event_info->user_data);
1008 } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1009 const char *address = NULL;
1010 const char *if_name = NULL;
1011 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1012 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1014 BT_DBG("BT_IPSP_CONNECTED");
1015 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1017 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1018 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1020 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1021 result, &bt_ipsp_iface_info,
1022 event_info->cb, event_info->user_data);
1023 } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1024 const char *address = NULL;
1025 const char *if_name = NULL;
1026 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1027 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1029 BT_DBG("BT_IPSP_DISCONNECTED");
1030 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1032 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1033 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1035 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1036 result, &bt_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);
1064 } else if (strcasecmp(signal_name, BT_PXP_PROPERTY_CHANGED) == 0) {
1065 const char *address = NULL;
1066 bluetooth_device_address_t dev_address = { {0} };
1067 int role, type, level;
1068 bt_pxp_property_changed_params_t params;
1070 BT_DBG("BT_PXP_PROPERTY_CHANGED");
1072 g_variant_get(parameters, "(isiii)", &result, &address, &role, &type, &level);
1074 _bt_convert_addr_string_to_type(dev_address.addr, address);
1075 memcpy(¶ms.device_address, &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1077 params.service_type = type;
1078 params.alert_lvl = level;
1080 _bt_common_event_cb(BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
1081 result, ¶ms, event_info->cb, event_info->user_data);
1085 void __bt_hid_event_filter(GDBusConnection *connection,
1086 const gchar *sender_name,
1087 const gchar *object_path,
1088 const gchar *interface_name,
1089 const gchar *signal_name,
1090 GVariant *parameters,
1093 bt_event_info_t *event_info;
1094 int result = BLUETOOTH_ERROR_NONE;
1096 event_info = (bt_event_info_t *)user_data;
1097 ret_if(event_info == NULL);
1099 if (strcasecmp(object_path, BT_HID_PATH) != 0)
1101 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1104 ret_if(signal_name == NULL);
1106 if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1107 const char *address = NULL;
1108 bluetooth_device_address_t dev_address = { {0} };
1110 g_variant_get(parameters, "(i&s)", &result, &address);
1112 _bt_convert_addr_string_to_type(dev_address.addr,
1115 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1116 result, &dev_address,
1117 event_info->cb, event_info->user_data);
1118 } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1119 const char *address = NULL;
1120 bluetooth_device_address_t dev_address = { {0} };
1122 g_variant_get(parameters, "(i&s)", &result, &address);
1124 BT_DBG("address: %s", address);
1126 _bt_convert_addr_string_to_type(dev_address.addr,
1129 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1130 result, &dev_address,
1131 event_info->cb, event_info->user_data);
1135 void __bt_headset_event_filter(GDBusConnection *connection,
1136 const gchar *sender_name,
1137 const gchar *object_path,
1138 const gchar *interface_name,
1139 const gchar *signal_name,
1140 GVariant *parameters,
1143 bt_event_info_t *event_info;
1144 int result = BLUETOOTH_ERROR_NONE;
1145 event_info = (bt_event_info_t *)user_data;
1146 ret_if(event_info == NULL);
1148 if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1150 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1153 ret_if(signal_name == NULL);
1155 if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1156 char *address = NULL;
1158 g_variant_get(parameters, "(i&s)", &result, &address);
1160 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1162 event_info->cb, event_info->user_data);
1163 } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1164 char *address = NULL;
1166 g_variant_get(parameters, "(i&s)", &result, &address);
1168 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1170 event_info->cb, event_info->user_data);
1171 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1172 char *address = NULL;
1174 g_variant_get(parameters, "(i&s)", &result, &address);
1176 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1178 event_info->cb, event_info->user_data);
1179 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1180 char *address = NULL;
1182 g_variant_get(parameters, "(i&s)", &result, &address);
1184 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1186 event_info->cb, event_info->user_data);
1187 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1188 char *address = NULL;
1190 g_variant_get(parameters, "(i&s)", &result, &address);
1191 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1193 event_info->cb, event_info->user_data);
1194 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1195 char *address = NULL;
1197 g_variant_get(parameters, "(i&s)", &result, &address);
1199 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1201 event_info->cb, event_info->user_data);
1202 } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1205 char *address = NULL;
1207 g_variant_get(parameters, "(i&sq)", &result, &address,
1209 gain = (unsigned int)spkr_gain;
1211 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1213 event_info->cb, event_info->user_data);
1214 } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1217 char *address = NULL;
1219 g_variant_get(parameters, "(i&sq)", &result,
1220 &address, &mic_gain);
1221 gain = (unsigned int)mic_gain;
1223 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1225 event_info->cb, event_info->user_data);
1229 void __bt_hid_device_event_filter(GDBusConnection *connection,
1230 const gchar *sender_name,
1231 const gchar *object_path,
1232 const gchar *interface_name,
1233 const gchar *signal_name,
1234 GVariant *parameters,
1237 bt_event_info_t *event_info;
1238 int result = BLUETOOTH_ERROR_NONE;
1240 event_info = (bt_event_info_t *)user_data;
1241 ret_if(event_info == NULL);
1242 if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1244 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1247 ret_if(signal_name == NULL);
1249 if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1250 const char *address = NULL;
1251 bluetooth_device_address_t dev_address = { {0} };
1253 g_variant_get(parameters, "(i&s)", &result, &address);
1255 _bt_convert_addr_string_to_type(dev_address.addr,
1258 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1259 result, &dev_address,
1260 event_info->cb, event_info->user_data);
1261 } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1262 const char *address = NULL;
1263 bluetooth_device_address_t dev_address = { {0} };
1265 g_variant_get(parameters, "(i&s)", &result, &address);
1267 BT_DBG("address: %s", address);
1269 _bt_convert_addr_string_to_type(dev_address.addr,
1272 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1273 result, &dev_address,
1274 event_info->cb, event_info->user_data);
1275 } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_CONNECTED) == 0) {
1276 BT_INFO_C("Type %s", g_variant_get_type_string(parameters));
1277 const char *address = NULL;
1278 bluetooth_device_address_t dev_address = { {0} };
1280 g_variant_get(parameters, "(i&s)", &result, &address);
1282 BT_DBG("address: %s", address);
1283 _bt_convert_addr_string_to_type(dev_address.addr,
1285 int ctrl = -1, intr = -1;
1286 _bt_hid_device_get_fd(address, &ctrl, &intr);
1287 if (ctrl != -1 && intr != -1) {
1288 new_hid_connection(NULL, ctrl, &dev_address);
1289 new_hid_connection(NULL, intr, &dev_address);
1291 } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_DISCONNECTED) == 0) {
1292 const char *address = NULL;
1293 g_variant_get(parameters, "(i&s)", &result, &address);
1295 BT_DBG("address: %s", address);
1298 void __bt_a2dp_source_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_A2DP_SOURCE_PATH) != 0)
1313 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1316 ret_if(signal_name == NULL);
1318 if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1319 char *address = NULL;
1321 g_variant_get(parameters, "(i&s)", &result, &address);
1322 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1324 event_info->cb, event_info->user_data);
1325 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1326 char *address = NULL;
1328 g_variant_get(parameters, "(i&s)", &result, &address);
1330 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1332 event_info->cb, event_info->user_data);
1336 void __bt_network_event_filter(GDBusConnection *connection,
1337 const gchar *sender_name,
1338 const gchar *object_path,
1339 const gchar *interface_name,
1340 const gchar *signal_name,
1341 GVariant *parameters,
1344 bt_event_info_t *event_info;
1345 int result = BLUETOOTH_ERROR_NONE;
1346 event_info = (bt_event_info_t *)user_data;
1347 ret_if(event_info == NULL);
1349 if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1351 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1354 ret_if(signal_name == NULL);
1356 if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1357 const char *address = NULL;
1358 bluetooth_device_address_t dev_address = { {0} };
1360 g_variant_get(parameters, "(i&s)", &result, &address);
1362 _bt_convert_addr_string_to_type(dev_address.addr,
1365 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1366 result, &dev_address,
1367 event_info->cb, event_info->user_data);
1368 } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1369 const char *address = NULL;
1370 bluetooth_device_address_t dev_address = { {0} };
1372 g_variant_get(parameters, "(i&s)", &result, &address);
1374 _bt_convert_addr_string_to_type(dev_address.addr,
1377 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1378 result, &dev_address,
1379 event_info->cb, event_info->user_data);
1380 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1381 const char *device = NULL;
1382 const char *address = NULL;
1383 bluetooth_network_device_info_t network_info;
1385 g_variant_get(parameters, "(i&s&s)", &result,
1388 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1390 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1393 _bt_print_device_address_t(&network_info.device_address);
1394 g_strlcpy(network_info.interface_name, device,
1395 sizeof(network_info.interface_name));
1397 DBG_SECURE("Interface: %s", network_info.interface_name);
1399 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1400 result, &network_info,
1401 event_info->cb, event_info->user_data);
1402 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1403 const char *device = NULL;
1404 const char *address = NULL;
1405 bluetooth_network_device_info_t network_info;
1407 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1409 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1411 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1414 _bt_print_device_address_t(&network_info.device_address);
1416 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1417 result, &network_info,
1418 event_info->cb, event_info->user_data);
1422 void __bt_avrcp_event_filter(GDBusConnection *connection,
1423 const gchar *sender_name,
1424 const gchar *object_path,
1425 const gchar *interface_name,
1426 const gchar *signal_name,
1427 GVariant *parameters,
1430 bt_event_info_t *event_info;
1431 int result = BLUETOOTH_ERROR_NONE;
1432 event_info = (bt_event_info_t *)user_data;
1433 ret_if(event_info == NULL);
1435 if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1437 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1440 ret_if(signal_name == NULL);
1442 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1443 char *address = NULL;
1445 g_variant_get(parameters, "(i&s)", &result, &address);
1447 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1449 event_info->cb, event_info->user_data);
1450 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1451 char *address = NULL;
1453 g_variant_get(parameters, "(i&s)", &result, &address);
1455 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1457 event_info->cb, event_info->user_data);
1458 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1459 unsigned int status;
1461 g_variant_get(parameters, "(u)", &status);
1462 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1464 event_info->cb, event_info->user_data);
1465 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1466 unsigned int status;
1468 g_variant_get(parameters, "(u)", &status);
1469 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1471 event_info->cb, event_info->user_data);
1472 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1473 unsigned int status;
1475 g_variant_get(parameters, "(u)", &status);
1476 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1478 event_info->cb, event_info->user_data);
1479 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1480 unsigned int status;
1482 g_variant_get(parameters, "(u)", &status);
1483 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1485 event_info->cb, event_info->user_data);
1489 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1490 const gchar *sender_name,
1491 const gchar *object_path,
1492 const gchar *interface_name,
1493 const gchar *signal_name,
1494 GVariant *parameters,
1497 bt_event_info_t *event_info;
1498 int result = BLUETOOTH_ERROR_NONE;
1499 event_info = (bt_event_info_t *)user_data;
1500 ret_if(event_info == NULL);
1502 if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1504 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1507 ret_if(signal_name == NULL);
1509 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1510 char *address = NULL;
1512 g_variant_get(parameters, "(i&s)", &result, &address);
1514 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1516 event_info->cb, event_info->user_data);
1517 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1518 char *address = NULL;
1520 g_variant_get(parameters, "(i&s)", &result, &address);
1522 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1524 event_info->cb, event_info->user_data);
1525 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1526 unsigned int status;
1528 g_variant_get(parameters, "(u)", &status);
1529 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1531 event_info->cb, event_info->user_data);
1532 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1533 unsigned int status;
1535 g_variant_get(parameters, "(u)", &status);
1536 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1538 event_info->cb, event_info->user_data);
1539 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1540 unsigned int status;
1542 g_variant_get(parameters, "(u)", &status);
1543 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1545 event_info->cb, event_info->user_data);
1546 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1547 unsigned int status;
1549 g_variant_get(parameters, "(u)", &status);
1550 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1552 event_info->cb, event_info->user_data);
1553 } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1554 unsigned int status;
1556 g_variant_get(parameters, "(u)", &status);
1557 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1559 event_info->cb, event_info->user_data);
1560 } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1561 unsigned int status;
1563 g_variant_get(parameters, "(u)", &status);
1564 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1566 event_info->cb, event_info->user_data);
1567 } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1568 media_metadata_attributes_t metadata;
1573 unsigned int total_tracks;
1574 unsigned int number;
1575 unsigned int duration;
1577 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1578 &artist, &album, &genre,
1579 &total_tracks, &number,
1581 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1583 metadata.title = title;
1584 metadata.artist = artist;
1585 metadata.album = album;
1586 metadata.genre = genre;
1587 metadata.total_tracks = total_tracks;
1588 metadata.number = number;
1589 metadata.duration = duration;
1591 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1593 event_info->cb, event_info->user_data);
1597 void __bt_opp_client_event_filter(GDBusConnection *connection,
1598 const gchar *sender_name,
1599 const gchar *object_path,
1600 const gchar *interface_name,
1601 const gchar *signal_name,
1602 GVariant *parameters,
1605 bt_event_info_t *event_info;
1606 int result = BLUETOOTH_ERROR_NONE;
1607 event_info = (bt_event_info_t *)user_data;
1608 ret_if(event_info == NULL);
1610 if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1612 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1615 ret_if(signal_name == NULL);
1617 if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1618 const char *address = NULL;
1620 bluetooth_device_address_t dev_address = { {0} };
1622 g_variant_get(parameters, "(i&si)", &result,
1623 &address, &request_id);
1625 if (__bt_is_request_id_exist(request_id) == FALSE) {
1626 BT_ERR("Different request id!");
1630 _bt_convert_addr_string_to_type(dev_address.addr,
1633 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1634 result, &dev_address,
1635 event_info->cb, event_info->user_data);
1637 if (result != BLUETOOTH_ERROR_NONE)
1638 __bt_remove_push_request_id(request_id);
1640 } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1641 const char *address = NULL;
1643 bluetooth_device_address_t dev_address = { {0} };
1645 g_variant_get(parameters, "(i&si)", &result, &address,
1648 if (__bt_is_request_id_exist(request_id) == FALSE) {
1649 BT_ERR("Different request id!");
1653 _bt_convert_addr_string_to_type(dev_address.addr,
1656 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1657 result, &dev_address,
1658 event_info->cb, event_info->user_data);
1660 __bt_remove_push_request_id(request_id);
1661 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1662 const char *file_name = NULL;
1663 const char *device_addr = NULL;
1666 bt_opc_transfer_info_t transfer_info;
1668 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
1669 &size, &request_id);
1671 if (__bt_is_request_id_exist(request_id) == FALSE) {
1672 BT_ERR("Different request id!");
1676 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1678 transfer_info.filename = g_strdup(file_name);
1679 transfer_info.device_addr = g_strdup(device_addr);
1680 transfer_info.size = size;
1682 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1683 result, &transfer_info,
1684 event_info->cb, event_info->user_data);
1686 g_free(transfer_info.device_addr);
1687 g_free(transfer_info.filename);
1688 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1689 const char *file_name = NULL;
1693 bt_opc_transfer_info_t transfer_info;
1695 g_variant_get(parameters, "(i&stii)", &result,
1696 &file_name, &size, &progress, &request_id);
1698 if (__bt_is_request_id_exist(request_id) == FALSE) {
1699 BT_ERR("Different request id!");
1703 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1705 transfer_info.filename = g_strdup(file_name);
1706 transfer_info.size = size;
1707 transfer_info.percentage = progress;
1709 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1710 result, &transfer_info,
1711 event_info->cb, event_info->user_data);
1713 g_free(transfer_info.filename);
1714 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1715 const char *file_name = NULL;
1716 const char *device_addr = NULL;
1719 bt_opc_transfer_info_t transfer_info;
1721 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
1722 &file_name, &size, &request_id);
1724 if (__bt_is_request_id_exist(request_id) == FALSE) {
1725 BT_ERR("Different request id!");
1729 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1731 transfer_info.device_addr = g_strdup(device_addr);
1732 transfer_info.filename = g_strdup(file_name);
1733 transfer_info.size = size;
1735 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1736 result, &transfer_info,
1737 event_info->cb, event_info->user_data);
1739 g_free(transfer_info.device_addr);
1740 g_free(transfer_info.filename);
1744 void __bt_opp_server_event_filter(GDBusConnection *connection,
1745 const gchar *sender_name,
1746 const gchar *object_path,
1747 const gchar *interface_name,
1748 const gchar *signal_name,
1749 GVariant *parameters,
1752 bt_event_info_t *event_info;
1753 int result = BLUETOOTH_ERROR_NONE;
1754 event_info = (bt_event_info_t *)user_data;
1755 ret_if(event_info == NULL);
1757 if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1759 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1762 ret_if(signal_name == NULL);
1764 if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1765 /* Native only event */
1766 const char *file_name = NULL;
1767 const char *address = NULL;
1768 const char *device_name = NULL;
1770 bt_obex_server_authorize_into_t auth_info;
1772 g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
1773 &address, &device_name);
1775 /* OSP server: Don't get this event */
1776 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1778 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1780 auth_info.filename = g_strdup(file_name);
1781 auth_info.length = size;
1782 auth_info.address = g_strdup(address);
1783 auth_info.name = g_strdup(device_name);
1784 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1786 event_info->cb, event_info->user_data);
1788 g_free(auth_info.filename);
1789 g_free(auth_info.address);
1790 g_free(auth_info.name);
1791 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1792 /* OSP only event */
1793 const char *address = NULL;
1794 const char *name = NULL;
1795 bluetooth_device_address_t dev_address = { {0} };
1797 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1799 /* Native server: Don't get this event */
1800 ret_if(obex_server_id == BT_NATIVE_SERVER);
1802 _bt_convert_addr_string_to_type(dev_address.addr,
1805 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1806 result, &dev_address,
1807 event_info->cb, event_info->user_data);
1808 } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1809 bt_obex_server_connection_info_t conn_info = {0, };
1810 char *address = NULL;
1812 int transfer_id = -1;
1813 g_variant_get(parameters, "(i&s&si)", &result,
1814 &address, &name, &transfer_id);
1816 conn_info.address = g_strdup(address);
1817 conn_info.device_name = g_strdup(name);
1818 conn_info.transfer_id = transfer_id;
1820 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1821 result, &conn_info, event_info->cb,
1822 event_info->user_data);
1824 g_free(conn_info.address);
1825 g_free(conn_info.device_name);
1826 } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1827 bt_obex_server_transfer_info_t transfer_info = {0, };
1828 char *address = NULL;
1829 int transfer_id = -1;
1830 g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
1831 DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
1833 transfer_info.address = g_strdup(address);
1834 transfer_info.transfer_id = transfer_id;
1836 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1837 result, &transfer_info, event_info->cb,
1838 event_info->user_data);
1839 g_free(transfer_info.address);
1840 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1841 const char *device_name = NULL;
1842 const char *file_name = NULL;
1843 const char *type = NULL;
1844 const char *address = NULL;
1845 GVariantIter *iter = NULL;
1848 int transfer_id = 0;
1849 int server_type = 0; /* bt_server_type_t */
1851 bt_obex_server_transfer_info_t transfer_info;
1853 g_variant_get(parameters, "(i&s&s&s&stii(ay))", &result, &device_name,
1854 &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
1856 /* Other server's event */
1857 ret_if(obex_server_id != server_type &&
1858 server_type != BT_FTP_SERVER);
1860 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1862 transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
1864 for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
1865 transfer_info.contact_auth_info[i] = byte;
1867 transfer_info.device_name = g_strdup(device_name);
1868 transfer_info.filename = g_strdup(file_name);
1869 transfer_info.type = g_strdup(type);
1870 transfer_info.address = g_strdup(address);
1871 transfer_info.file_size = size;
1872 transfer_info.transfer_id = transfer_id;
1873 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1874 FTP_SERVER : OPP_SERVER;
1876 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1877 result, &transfer_info,
1878 event_info->cb, event_info->user_data);
1880 g_free(transfer_info.filename);
1881 g_free(transfer_info.type);
1882 g_free(transfer_info.device_name);
1883 g_free(transfer_info.address);
1884 g_free(transfer_info.contact_auth_info);
1885 g_variant_iter_free(iter);
1886 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1887 const char *file_name = NULL;
1888 const char *type = NULL;
1889 const char *device_name = NULL;
1890 const char *address = NULL;
1891 int transfer_id = 0;
1893 int server_type = 0; /* bt_server_type_t */
1895 bt_obex_server_transfer_info_t transfer_info;
1897 g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
1898 &type, &device_name, &address, &size, &transfer_id,
1899 &progress, &server_type);
1901 /* Other server's event */
1902 ret_if(obex_server_id != server_type &&
1903 server_type != BT_FTP_SERVER);
1905 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1907 transfer_info.filename = g_strdup(file_name);
1908 transfer_info.type = g_strdup(type);
1909 transfer_info.device_name = g_strdup(device_name);
1910 transfer_info.address = g_strdup(address);
1911 transfer_info.file_size = size;
1912 transfer_info.transfer_id = transfer_id;
1913 transfer_info.percentage = progress;
1914 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1915 FTP_SERVER : OPP_SERVER;
1917 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1918 result, &transfer_info,
1919 event_info->cb, event_info->user_data);
1921 g_free(transfer_info.filename);
1922 g_free(transfer_info.device_name);
1923 g_free(transfer_info.address);
1924 g_free(transfer_info.type);
1925 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1926 const char *file_name = NULL;
1927 const char *device_name = NULL;
1928 const char *address = NULL;
1929 const char *type = NULL;
1930 const char *file_path;
1931 int transfer_id = 0;
1932 int server_type = 0; /* bt_server_type_t */
1934 bt_obex_server_transfer_info_t transfer_info;
1936 g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
1937 &type, &device_name, &file_path, &address, &size,
1938 &transfer_id, &server_type);
1940 /* Other server's event */
1941 ret_if(obex_server_id != server_type &&
1942 server_type != BT_FTP_SERVER);
1944 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1946 transfer_info.filename = g_strdup(file_name);
1947 transfer_info.type = g_strdup(type);
1948 transfer_info.device_name = g_strdup(device_name);
1949 transfer_info.file_path = g_strdup(file_path);
1950 transfer_info.address = g_strdup(address);
1951 transfer_info.file_size = size;
1952 transfer_info.transfer_id = transfer_id;
1953 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1954 FTP_SERVER : OPP_SERVER;
1956 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1957 result, &transfer_info,
1958 event_info->cb, event_info->user_data);
1960 g_free(transfer_info.filename);
1961 g_free(transfer_info.type);
1962 g_free(transfer_info.device_name);
1963 g_free(transfer_info.address);
1964 g_free(transfer_info.file_path);
1968 void __bt_map_client_event_filter(GDBusConnection *connection,
1969 const gchar *sender_name,
1970 const gchar *object_path,
1971 const gchar *interface_name,
1972 const gchar *signal_name,
1973 GVariant *parameters,
1976 BT_DBG("Entered __bt_map_client_event_filter");
1977 bt_event_info_t *event_info;
1978 int result = BLUETOOTH_ERROR_NONE;
1979 event_info = (bt_event_info_t *)user_data;
1980 ret_if(event_info == NULL);
1982 if (strcasecmp(object_path, BT_MAP_CLIENT_PATH) != 0)
1984 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1987 ret_if(signal_name == NULL);
1989 if (strcasecmp(signal_name, BT_MAP_CONNECTED) == 0) {
1990 const char *address = NULL;
1992 bluetooth_device_address_t dev_address = { {0} };
1994 g_variant_get(parameters, "(i&si)", &result,
1995 &address, &request_id);
1997 if (__bt_is_request_id_exist(request_id) == FALSE) {
1998 BT_ERR("Different request id!");
2002 _bt_convert_addr_string_to_type(dev_address.addr,
2005 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_CONNECTED,
2006 result, &dev_address,
2007 event_info->cb, event_info->user_data);
2009 if (result != BLUETOOTH_ERROR_NONE)
2010 __bt_remove_push_request_id(request_id);
2011 } else if (strcasecmp(signal_name, BT_MAP_DISCONNECTED) == 0) {
2012 const char *address = NULL;
2014 bluetooth_device_address_t dev_address = { {0} };
2016 g_variant_get(parameters, "(i&si)", &result, &address,
2019 if (__bt_is_request_id_exist(request_id) == FALSE) {
2020 BT_ERR("Different request id!");
2024 _bt_convert_addr_string_to_type(dev_address.addr,
2027 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_DISCONNECTED,
2028 result, &dev_address,
2029 event_info->cb, event_info->user_data);
2031 __bt_remove_push_request_id(request_id);
2032 } else if (strcasecmp(signal_name, BT_MAP_LIST_FOLDERS_COMPLETE) == 0) {
2034 GVariant* folder_list_var = NULL;
2036 g_variant_get(parameters, "(iiv)", &result, &request_id, &folder_list_var);
2037 if (__bt_is_request_id_exist(request_id) == FALSE) {
2038 BT_ERR("Different request id!");
2044 bt_map_client_folders_s folders_struct = {0,};
2045 g_variant_get(folder_list_var, "(aa{sv})", &iter);
2047 folders_struct.size = g_variant_iter_n_children(iter);
2048 folders_struct.names = (char**) malloc(folders_struct.size * sizeof(*(folders_struct.names)));
2049 BT_DBG("g_variant_iter_n_children: %d", folders_struct.size);
2050 GVariantIter* res = NULL;
2052 while (g_variant_iter_loop(iter, "a{sv}", &res)) {
2054 GVariant* value = NULL;
2055 while (g_variant_iter_loop(res, "{sv}", &key, &value)) {
2056 char* string_value = NULL;
2057 g_variant_get(value, "s", &string_value);
2058 BT_DBG("got folder name: %s", string_value);
2059 folders_struct.names[i] = strdup(string_value);
2063 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE,
2064 result, &folders_struct,
2065 event_info->cb, event_info->user_data);
2067 __bt_remove_push_request_id(request_id);
2069 // freeing resources
2071 free(folders_struct.names[i]);
2072 folders_struct.names[i] = NULL;
2074 free(folders_struct.names);
2076 g_variant_unref(folder_list_var);
2078 } else if (strcasecmp(signal_name, BT_MAP_FILTER_FIELDS_COMPLETE) == 0) {
2079 BT_DBG("BT_MAP_LIST_FOLDERS_COMPLETE");
2084 bt_map_list_filter_fields_info_t fields_info = {0,};
2086 g_variant_get(parameters, "(ivi)", &result, &value, &request_id);
2088 if (__bt_is_request_id_exist(request_id) == FALSE) {
2089 BT_ERR("Different request id!");
2094 GVariantIter *iter = NULL;
2095 g_variant_get(value, "(as)", &iter);
2096 fields_info.size = g_variant_iter_n_children(iter);
2099 fields_info.fields = malloc(fields_info.size * sizeof(char*));
2100 while (g_variant_iter_loop(iter, "s", &field)) {
2101 fields_info.fields[i] = strdup(field);
2106 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE,
2107 request_id, &fields_info,
2108 event_info->cb, event_info->user_data);
2111 free(fields_info.fields[i]);
2112 fields_info.fields[i] = NULL;
2114 free(fields_info.fields);
2116 __bt_remove_push_request_id(request_id);
2117 g_variant_unref(value);
2118 } else if (strcasecmp(signal_name, BT_MAP_LIST_MESSAGES_COMPLETE) == 0) {
2120 GVariant* messages_list_var = NULL;
2121 g_variant_get(parameters, "(iiv)", &result, &request_id, &messages_list_var);
2122 if (__bt_is_request_id_exist(request_id) == FALSE) {
2123 BT_ERR("Different request id!");
2127 bt_map_client_message_items_s messages_struct = {0,};
2130 g_variant_get(messages_list_var, "(a{oa{sv}})", &iter);
2131 messages_struct.size = g_variant_iter_n_children(iter);
2132 messages_struct.message_items = (bt_map_client_message_item_t*)
2133 malloc(messages_struct.size * sizeof(*(messages_struct.message_items)));
2134 BT_DBG("g_variant_iter_n_children: %d", messages_struct.size);
2136 char *object = NULL;
2137 GVariantIter *properites = NULL;
2139 while (g_variant_iter_loop(iter, "{oa{sv}}", &object, &properites)) {
2140 messages_struct.message_items[i].message_object = strdup(object);
2141 BT_DBG("Message found: %s", messages_struct.message_items[i].message_object);
2142 messages_struct.message_items[i].folder = NULL;
2143 messages_struct.message_items[i].subject = NULL;
2144 messages_struct.message_items[i].timestamp = NULL;
2145 messages_struct.message_items[i].sender = NULL;
2146 messages_struct.message_items[i].sender_address = NULL;
2147 messages_struct.message_items[i].reply_to = NULL;
2148 messages_struct.message_items[i].recipient = NULL;
2149 messages_struct.message_items[i].recipient_address = NULL;
2150 messages_struct.message_items[i].type = NULL;
2151 messages_struct.message_items[i].size = -1;
2152 messages_struct.message_items[i].is_text = -1;
2153 messages_struct.message_items[i].status = NULL;
2154 messages_struct.message_items[i].attachment_size = -1;
2155 messages_struct.message_items[i].is_priority = -1;
2156 messages_struct.message_items[i].is_read = -1;
2157 messages_struct.message_items[i].is_sent = -1;
2158 messages_struct.message_items[i].is_protected = -1;
2160 GVariant *value = NULL;
2161 while (g_variant_iter_loop(properites, "{sv}", &key, &value)) {
2162 char *value_string = NULL;
2163 uint64_t value_int = -1;
2164 bool value_bool = false;
2165 if (strcmp(key, "Folder") == 0) {
2166 g_variant_get(value, "s", &value_string);
2167 messages_struct.message_items[i].folder = strdup(value_string);
2168 BT_DBG(" Folder: %s", value_string);
2169 } else if (strcmp(key, "Subject") == 0) {
2170 g_variant_get(value, "s", &value_string);
2171 messages_struct.message_items[i].subject = strdup(value_string);
2172 BT_DBG(" Subject: %s", value_string);
2173 } else if (strcmp(key, "Timestamp") == 0) {
2174 g_variant_get(value, "s", &value_string);
2175 messages_struct.message_items[i].timestamp = strdup(value_string);
2176 BT_DBG(" Timestamp: %s", value_string);
2177 } else if (strcmp(key, "Sender") == 0) {
2178 g_variant_get(value, "s", &value_string);
2179 messages_struct.message_items[i].sender = strdup(value_string);
2180 BT_DBG(" Sender: %s", value_string);
2181 } else if (strcmp(key, "SenderAddress") == 0) {
2182 g_variant_get(value, "s", &value_string);
2183 messages_struct.message_items[i].sender_address = strdup(value_string);
2184 BT_DBG(" SenderAddress: %s", value_string);
2185 } else if (strcmp(key, "ReplyTo") == 0) {
2186 g_variant_get(value, "s", &value_string);
2187 messages_struct.message_items[i].reply_to = strdup(value_string);
2188 BT_DBG(" ReplyTo: %s", value_string);
2189 } else if (strcmp(key, "Recipient") == 0) {
2190 g_variant_get(value, "s", &value_string);
2191 messages_struct.message_items[i].recipient = strdup(value_string);
2192 BT_DBG(" Recipient: %s", value_string);
2193 } else if (strcmp(key, "RecipientAddress") == 0) {
2194 g_variant_get(value, "s", &value_string);
2195 messages_struct.message_items[i].recipient_address = strdup(value_string);
2196 BT_DBG(" RecipientAddress: %s", value_string);
2197 } else if (strcmp(key, "Type") == 0) {
2198 g_variant_get(value, "s", &value_string);
2199 messages_struct.message_items[i].type = strdup(value_string);
2200 BT_DBG(" Type: %s", value_string);
2201 } else if (strcmp(key, "Size") == 0) {
2202 g_variant_get(value, "t", &value_int);
2203 messages_struct.message_items[i].size = value_int;
2204 BT_DBG(" Size: %d", value_int);
2205 } else if (strcmp(key, "Text") == 0) {
2206 g_variant_get(value, "b", &value_bool);
2207 messages_struct.message_items[i].is_text = value_bool ? 1 : 0;
2208 BT_DBG(" Text: %s", value_bool ? "true" : "false");
2209 } else if (strcmp(key, "Status") == 0) {
2210 g_variant_get(value, "s", &value_string);
2211 messages_struct.message_items[i].status = strdup(value_string);
2212 BT_DBG(" Status: %s", value_string);
2213 } else if (strcmp(key, "AttachmentSize") == 0) {
2214 g_variant_get(value, "t", &value_int);
2215 messages_struct.message_items[i].attachment_size = value_int;
2216 BT_DBG(" AttachmentSize: %d", value_int);
2217 } else if (strcmp(key, "Priority") == 0) {
2218 g_variant_get(value, "b", &value_bool);
2219 messages_struct.message_items[i].is_priority = value_bool ? 1 : 0;
2220 BT_DBG(" Priority: %s", value_bool ? "true" : "false");
2221 } else if (strcmp(key, "Read") == 0) {
2222 g_variant_get(value, "b", &value_bool);
2223 messages_struct.message_items[i].is_read = value_bool ? 1 : 0;
2224 BT_DBG(" Read: %s", value_bool ? "true" : "false");
2225 } else if (strcmp(key, "Sent") == 0) {
2226 g_variant_get(value, "b", &value_bool);
2227 messages_struct.message_items[i].is_sent = value_bool ? 1 : 0;
2228 BT_DBG(" Sent: %s", value_bool ? "true" : "false");
2229 } else if (strcmp(key, "Protected") == 0) {
2230 g_variant_get(value, "b", &value_bool);
2231 messages_struct.message_items[i].is_protected = value_bool ? 1 : 0;
2232 BT_DBG(" Protected: %s", value_bool ? "true" : "false");
2238 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE,
2239 result, &messages_struct,
2240 event_info->cb, event_info->user_data);
2242 __bt_remove_push_request_id(request_id);
2245 free(messages_struct.message_items[i].folder);
2246 free(messages_struct.message_items[i].subject);
2247 free(messages_struct.message_items[i].timestamp);
2248 free(messages_struct.message_items[i].sender);
2249 free(messages_struct.message_items[i].sender_address);
2250 free(messages_struct.message_items[i].reply_to);
2251 free(messages_struct.message_items[i].recipient);
2252 free(messages_struct.message_items[i].recipient_address);
2253 free(messages_struct.message_items[i].type);
2254 free(messages_struct.message_items[i].status);
2256 free(messages_struct.message_items);
2258 g_variant_unref(messages_list_var);
2259 } else if (strcasecmp(signal_name, BT_MAP_GET_MESSAGE_COMPLETE) == 0) {
2260 BT_DBG("BT_MAP_GET_MESSAGE_COMPLETE");
2263 g_variant_get(parameters, "(ii)", &result, &request_id);
2264 if (__bt_is_request_id_exist(request_id) == FALSE) {
2265 BT_ERR("Different request id!");
2269 // currently there is no result value passed from here, just passing NULL
2270 void* some_result_value = NULL;
2271 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE,
2272 result, some_result_value, event_info->cb, event_info->user_data);
2274 __bt_remove_push_request_id(request_id);
2275 } else if (strcasecmp(signal_name, BT_MAP_PUSH_MESSAGE_COMPLETE) == 0) {
2276 BT_DBG("BT_MAP_PUSH_MESSAGE_COMPLETE");
2279 g_variant_get(parameters, "(ii)", &result, &request_id);
2280 if (__bt_is_request_id_exist(request_id) == FALSE) {
2281 BT_ERR("Different request id!");
2285 // currently there is no result value passed from here, just passing NULL
2286 void* some_result_value = NULL;
2287 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_PUSH_MESSAGE_COMPLETE,
2288 result, some_result_value, event_info->cb, event_info->user_data);
2290 __bt_remove_push_request_id(request_id);
2295 void __bt_pbap_client_event_filter(GDBusConnection *connection,
2296 const gchar *sender_name,
2297 const gchar *object_path,
2298 const gchar *interface_name,
2299 const gchar *signal_name,
2300 GVariant *parameters,
2303 bt_event_info_t *event_info;
2304 int result = BLUETOOTH_ERROR_NONE;
2305 event_info = (bt_event_info_t *)user_data;
2307 ret_if(event_info == NULL);
2309 if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
2312 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2315 ret_if(signal_name == NULL);
2317 BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2319 if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2320 bt_pbap_connected_t connected = { { { 0 }, }, };
2321 char *address = NULL;
2323 g_variant_get(parameters, "(i&s)", &result, &address);
2324 BT_DBG("address: %s", address);
2326 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2329 connected.connected = 1;
2331 connected.connected = 0;
2333 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2335 event_info->cb, event_info->user_data);
2336 } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2337 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2338 char *address = NULL;
2340 g_variant_get(parameters, "(i&s)", &result, &address);
2341 BT_DBG("address: %s", address);
2343 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2345 disconnected.connected = 0;
2347 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
2348 result, &disconnected,
2349 event_info->cb, event_info->user_data);
2350 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2351 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2352 char *address = NULL;
2355 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2357 BT_DBG("address: %s, size: %d", address, size);
2359 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2361 pb_size.size = size;
2363 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2365 event_info->cb, event_info->user_data);
2366 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2367 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2368 char *address = NULL;
2369 char *vcf_file = NULL;
2372 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2374 BT_DBG("address: %s, vcf_file: %s, success: %d",
2375 address, vcf_file, success);
2377 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2379 pb_pull.vcf_file = vcf_file;
2380 pb_pull.success = success;
2381 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2383 event_info->cb, event_info->user_data);
2384 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2385 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2386 char *address = NULL;
2388 gchar **list = NULL;
2389 GVariant *string_var;
2393 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2395 list = (gchar **)g_variant_get_strv(string_var, &count);
2399 for (i = 0; i < count; i++)
2400 BT_DBG("%s", list[i]);
2402 BT_DBG("address: %s, result: %d, count: %d, success: %d",
2403 address, result, count, success);
2405 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2407 vc_list.vcards = list;
2408 vc_list.length = count;
2409 vc_list.success = success;
2410 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2412 event_info->cb, event_info->user_data);
2414 g_variant_unref(string_var);
2416 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2417 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2418 char *address = NULL;
2419 char *vcf_file = NULL;
2422 g_variant_get(parameters, "(i&s&si)",
2423 &result, &address, &vcf_file, &success);
2425 BT_DBG("address: %s, vcf_file: %s, success: %d",
2426 address, vcf_file, success);
2428 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2429 vc_pull.vcf_file = vcf_file;
2430 vc_pull.success = success;
2431 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2433 event_info->cb, event_info->user_data);
2434 } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2435 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2436 char *address = NULL;
2438 gchar **list = NULL;
2439 GVariant *string_var;
2443 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2445 list = (gchar **)g_variant_get_strv(string_var, &count);
2447 for (i = 0; i < count; i++)
2448 BT_DBG("%s", list[i]);
2450 BT_DBG("address: %s success: %d", address, success);
2452 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2453 vc_list.vcards = list;
2454 vc_list.length = count;
2455 vc_list.success = success;
2456 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2458 event_info->cb, event_info->user_data);
2460 g_variant_unref(string_var);
2465 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2466 const gchar *sender_name,
2467 const gchar *object_path,
2468 const gchar *interface_name,
2469 const gchar *signal_name,
2470 GVariant *parameters,
2473 bt_event_info_t *event_info;
2474 int result = BLUETOOTH_ERROR_NONE;
2475 event_info = (bt_event_info_t *)user_data;
2476 ret_if(event_info == NULL);
2478 if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2480 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2483 ret_if(signal_name == NULL);
2485 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2486 const char *address = NULL;
2487 const char *uuid = NULL;
2489 bluetooth_rfcomm_connection_t conn_info;
2491 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2494 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2495 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2496 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2497 conn_info.socket_fd = socket_fd;
2498 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2501 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2503 event_info->cb, event_info->user_data);
2504 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2505 const char *address = NULL;
2506 const char *uuid = NULL;
2508 bluetooth_rfcomm_disconnection_t disconn_info;
2510 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2513 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2514 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2515 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2516 disconn_info.socket_fd = socket_fd;
2517 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2520 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2521 result, &disconn_info,
2522 event_info->cb, event_info->user_data);
2523 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2527 bluetooth_rfcomm_received_data_t data_r;
2530 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2533 buffer_len = g_variant_get_size(byte_var);
2534 buffer = (char *) g_variant_get_data(byte_var);
2536 data_r.socket_fd = socket_fd;
2537 data_r.buffer_size = buffer_len;
2538 data_r.buffer = buffer;
2540 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2542 event_info->cb, event_info->user_data);
2543 g_variant_unref(byte_var);
2547 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2548 const gchar *sender_name,
2549 const gchar *object_path,
2550 const gchar *interface_name,
2551 const gchar *signal_name,
2552 GVariant *parameters,
2555 bt_event_info_t *event_info;
2556 int result = BLUETOOTH_ERROR_NONE;
2557 event_info = (bt_event_info_t *)user_data;
2558 ret_if(event_info == NULL);
2560 if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2562 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2565 ret_if(signal_name == NULL);
2567 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2568 const char *address = NULL;
2569 const char *uuid = NULL;
2571 bluetooth_rfcomm_connection_t conn_info;
2573 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2576 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2577 conn_info.device_role = RFCOMM_ROLE_SERVER;
2578 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2579 conn_info.socket_fd = socket_fd;
2580 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2583 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2585 event_info->cb, event_info->user_data);
2586 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2587 const char *address = NULL;
2588 const char *uuid = NULL;
2590 bluetooth_rfcomm_disconnection_t disconn_info;
2592 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2595 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2596 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2597 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2598 disconn_info.socket_fd = socket_fd;
2599 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2602 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2603 result, &disconn_info,
2604 event_info->cb, event_info->user_data);
2605 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2606 /* OSP only event */
2607 bluetooth_rfcomm_connection_request_t req_ind;
2608 char *address = NULL;
2614 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2615 &uuid, &name, &path, &socket_fd);
2617 if (_check_uuid_path(path, uuid) == FALSE)
2620 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2621 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2624 req_ind.socket_fd = socket_fd;
2626 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2628 event_info->cb, event_info->user_data);
2629 } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2630 /* OSP only event */
2633 g_variant_get(parameters, "(in)", &result, &socket_fd);
2635 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2637 _bt_remove_server(socket_fd);
2638 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2639 char *buffer = NULL;
2642 bluetooth_rfcomm_received_data_t data_r;
2645 g_variant_get(parameters, "(in@ay)", &result,
2646 &socket_fd, &byte_var);
2648 buffer_len = g_variant_get_size(byte_var);
2649 buffer = (char *) g_variant_get_data(byte_var);
2651 data_r.socket_fd = socket_fd;
2652 data_r.buffer_size = buffer_len;
2653 data_r.buffer = buffer;
2655 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2657 event_info->cb, event_info->user_data);
2658 g_variant_unref(byte_var);
2662 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2663 const gchar *sender_name,
2664 const gchar *object_path,
2665 const gchar *interface_name,
2666 const gchar *signal_name,
2667 GVariant *parameters,
2672 bt_event_info_t *event_info;
2673 int result = BLUETOOTH_ERROR_NONE;
2674 event_info = (bt_event_info_t *)user_data;
2675 ret_if(event_info == NULL);
2678 if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2680 if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2683 ret_if(signal_name == NULL);
2685 BT_DBG("%s", signal_name);
2686 if (strcasecmp(signal_name, "Connected") == 0) {
2687 char *address = NULL;
2689 g_variant_get(parameters, "(s)", &address);
2690 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2692 event_info->cb, event_info->user_data);
2693 } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2694 char *address = NULL;
2696 g_variant_get(parameters, "(s)", &address);
2697 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2699 event_info->cb, event_info->user_data);
2700 } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2701 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2703 event_info->cb, event_info->user_data);
2704 } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2705 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2707 event_info->cb, event_info->user_data);
2708 } else if (strcasecmp(signal_name, "Ring") == 0) {
2709 char *phoneno = NULL;
2711 g_variant_get(parameters, "(&s)", &phoneno);
2713 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2715 event_info->cb, event_info->user_data);
2716 } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2717 char *phoneno = NULL;
2719 g_variant_get(parameters, "(&s)", &phoneno);
2721 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2723 event_info->cb, event_info->user_data);
2724 } else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2725 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2727 event_info->cb, event_info->user_data);
2728 } else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2729 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2731 event_info->cb, event_info->user_data);
2732 } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2733 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2735 event_info->cb, event_info->user_data);
2736 } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2737 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2739 event_info->cb, event_info->user_data);
2740 } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2741 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2743 event_info->cb, event_info->user_data);
2744 } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2745 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2747 event_info->cb, event_info->user_data);
2748 } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2749 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2751 event_info->cb, event_info->user_data);
2752 } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2753 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2755 event_info->cb, event_info->user_data);
2756 } else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2757 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2759 event_info->cb, event_info->user_data);
2760 } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2761 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2763 event_info->cb, event_info->user_data);
2764 } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2765 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2767 event_info->cb, event_info->user_data);
2768 } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2770 GVariant *var_data = NULL;
2771 char *number = NULL;
2772 int idx, dir, status, mpart;
2773 bt_hf_call_list_s *handle = NULL;
2775 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2777 BT_DBG("call count : %d", call_count);
2780 GVariantIter *iter = NULL;
2781 __bt_call_list_create(&handle);
2783 g_variant_get(var_data, "a(siiii)", &iter);
2784 while (g_variant_iter_loop(iter, "(siiii)", &number,
2785 &dir, &status, &mpart, &idx)) {
2786 BT_DBG("call number:%s, dir:%d, status : %d",
2787 number, dir, status);
2788 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2789 __bt_call_list_add(handle, number, dir,
2790 status, mpart, idx);
2792 g_variant_iter_free(iter);
2793 g_variant_unref(var_data);
2796 if (handle && (call_count == g_list_length(handle->list))) {
2797 handle->count = call_count;
2798 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2800 event_info->cb, event_info->user_data);
2802 BT_ERR(" Mismatch in call count : %d", call_count);
2805 __bt_call_list_destroy(handle);
2806 } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2808 g_variant_get(parameters, "(i)", &status);
2809 BT_DBG("status = [%d]\n", status);
2811 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2813 event_info->cb, event_info->user_data);
2815 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2817 event_info->cb, event_info->user_data);
2818 } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2820 g_variant_get(parameters, "(i)", &value);
2821 BT_DBG("Value = [%d]\n", value);
2822 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2824 event_info->cb, event_info->user_data);
2825 } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2828 bluetooth_vendor_dep_at_cmd_t cmd;
2829 g_variant_get(parameters, "(i&s)", &value, &msg);
2830 BT_DBG("Value = [%d], message = %s\n", value, msg);
2833 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2835 event_info->cb, event_info->user_data);
2836 } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
2839 bluetooth_hf_ciev_device_event_t dev_event;
2841 g_variant_get(parameters, "(&sv)", &property, &value);
2842 dev_event.value = g_variant_get_uint16(value);
2844 BT_DBG("Property: %s , value: %d", property, dev_event.value);
2845 g_variant_unref(value);
2847 if (strcasecmp(property, "BatteryCharge") == 0) {
2848 dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
2849 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2851 event_info->cb, event_info->user_data);
2852 } else if (strcasecmp(property, "SignalStrength") == 0) {
2853 dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
2854 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2856 event_info->cb, event_info->user_data);
2857 } else if (strcasecmp(property, "RegistrationStatus") == 0) {
2858 dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
2859 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2861 event_info->cb, event_info->user_data);
2867 static void __bt_tds_event_filter(GDBusConnection *connection,
2868 const gchar *sender_name,
2869 const gchar *object_path,
2870 const gchar *interface_name,
2871 const gchar *signal_name,
2872 GVariant *parameters,
2875 bt_event_info_t *event_info;
2876 event_info = (bt_event_info_t *)user_data;
2877 int result = BLUETOOTH_ERROR_NONE;
2879 ret_if(event_info == NULL);
2881 if (strcasecmp(object_path, BT_TDS_PATH) != 0)
2883 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2886 ret_if(signal_name == NULL);
2890 if (strcasecmp(signal_name, BT_TDS_ACTIVATION_REQUESTED) == 0) {
2891 bluetooth_tds_activation_req_t act_req;
2892 const char *address = NULL;
2893 char *buffer = NULL;
2897 g_variant_get(parameters, "(&si@ay)", &address,
2898 &transport, &byte_var);
2900 memset(&act_req, 0x00, sizeof(bluetooth_tds_activation_req_t));
2902 act_req.transport = transport;
2904 act_req.tds_data.length = g_variant_get_size(byte_var);
2905 if (act_req.tds_data.length > BLUETOOTH_TDS_DATA_LENGTH_MAX) {
2906 BT_INFO("tds data length > BLUETOOTH_TDS_DATA_LENGTH_MAX");
2907 act_req.tds_data.length = BLUETOOTH_TDS_DATA_LENGTH_MAX;
2909 buffer = (char *) g_variant_get_data(byte_var);
2910 memcpy(act_req.tds_data.data, buffer, act_req.tds_data.length);
2912 _bt_convert_addr_string_to_type(act_req.rem_addr.addr, address);
2914 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_REQUESTED,
2915 BLUETOOTH_ERROR_NONE, &act_req,
2916 event_info->cb, event_info->user_data);
2917 } else if (strcasecmp(signal_name, BT_TDS_TRANSPORT_DATA_RECEIVED) == 0) {
2918 BT_DBG("TDS Complete Block Data received");
2919 const char *address = NULL;
2923 GVariant *var = NULL;
2924 bluetooth_tds_transport_data_info_t *info = NULL;
2926 /* Extract data from DBUS params */
2927 g_variant_get(parameters, "(i&sn@ay)", &result, &address, &data_len, &var);
2928 data = (char *)g_variant_get_data(var);
2930 BT_DBG("Address [%s]", address);
2931 BT_DBG("Data len [%d]", data_len);
2934 for (k = 0; k < data_len ; k++)
2935 BT_DBG("Data[%d] [0x%x]", k, data[k]);
2937 if (data_len == 0) {
2939 g_variant_unref(var);
2943 info = g_malloc0(sizeof(bluetooth_tds_transport_data_info_t));
2944 info->data_length = data_len;
2945 info->data = g_memdup(data, data_len);
2947 _bt_convert_addr_string_to_type(info->device_address.addr,
2950 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED,
2952 event_info->cb, event_info->user_data);
2959 g_variant_unref(var);
2960 } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_RESULT) == 0) {
2961 BT_DBG("TDS Control point Activation result");
2962 const char *address = NULL;
2963 bluetooth_device_address_t dev_address = { {0} };
2965 /* Extract data from DBUS params */
2966 g_variant_get(parameters, "(i&s)", &result, &address);
2967 BT_DBG("Address [%s]", address);
2968 BT_DBG("Result [%d]", result);
2970 _bt_convert_addr_string_to_type(dev_address.addr,
2973 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_RESULT,
2974 result, &dev_address,
2975 event_info->cb, event_info->user_data);
2976 } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_INDICATION) == 0) {
2977 BT_DBG("TDS Control point Indication Response");
2978 bluetooth_tds_indication_res_t ind_res;
2979 const char *address = NULL;
2980 char *buffer = NULL;
2981 GVariant *byte_var = NULL;
2983 g_variant_get(parameters, "(&s@ay)", &address, &byte_var);
2985 memset(&ind_res, 0x00, sizeof(bluetooth_tds_indication_res_t));
2987 ind_res.tds_data.length = g_variant_get_size(byte_var);
2989 buffer = (char *) g_variant_get_data(byte_var);
2990 memcpy(ind_res.tds_data.data, buffer, ind_res.tds_data.length);
2992 _bt_convert_addr_string_to_type(ind_res.rem_addr.addr, address);
2994 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_INDICATION,
2995 BLUETOOTH_ERROR_NONE, &ind_res,
2996 event_info->cb, event_info->user_data);
2998 g_variant_unref(byte_var);
2999 } else if (strcasecmp(signal_name, BT_TDS_CONTROL_POINT_ENABLED) == 0) {
3000 BT_DBG("TDS Control point Enabled event");
3001 const char *address = NULL;
3002 bluetooth_device_address_t dev_address = { {0} };
3004 /* Extract data from DBUS params */
3005 g_variant_get(parameters, "(i&s)", &result, &address);
3006 BT_DBG("Address [%s]", address);
3007 BT_DBG("Result [%d]", result);
3009 _bt_convert_addr_string_to_type(dev_address.addr,
3012 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_CONTROL_POINT_ENABLED,
3013 result, &dev_address,
3014 event_info->cb, event_info->user_data);
3020 static void __bt_otp_event_filter(GDBusConnection *connection,
3021 const gchar *sender_name,
3022 const gchar *object_path,
3023 const gchar *interface_name,
3024 const gchar *signal_name,
3025 GVariant *parameters,
3028 bt_event_info_t *event_info;
3029 event_info = (bt_event_info_t *)user_data;
3030 int result = BLUETOOTH_ERROR_NONE;
3032 ret_if(event_info == NULL);
3034 if (strcasecmp(object_path, BT_OTP_PATH) != 0)
3036 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3039 ret_if(signal_name == NULL);
3043 if (strcasecmp(signal_name, BT_OTP_SERVER_STATE_CHANGED) == 0) {
3044 BT_DBG("OTP Server State Changed Event");
3045 bool status = FALSE;
3047 /* Extract data from DBUS params */
3048 g_variant_get(parameters, "(ib)", &result, &status);
3049 BT_DBG("Result [%d]", result);
3050 BT_DBG("Status [%s]", status ? "enabled" : "disabled");
3052 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_SERVER_STATE_CHANGED,
3053 result, &status, event_info->cb, event_info->user_data);
3054 } else if (strcasecmp(signal_name, BT_OTP_READ_CHAR_VAL) == 0) {
3055 BT_DBG("OTP Read Data received");
3056 const char *handle = NULL;
3059 GVariant *var = NULL;
3060 bluetooth_otp_resp_info_t *info = NULL;
3062 /* Extract data from DBUS params */
3063 g_variant_get(parameters, "(i&sn@ay)", &result, &handle, &data_len, &var);
3064 data = (char *)g_variant_get_data(var);
3066 BT_DBG("Handle [%s]", handle);
3067 BT_DBG("Data len [%d]", data_len);
3069 if (data_len == 0) {
3072 g_variant_unref(var);
3076 info = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3077 info->data_length = data_len;
3078 info->data = g_memdup(data, data_len);
3079 info->handle = g_strdup(handle);
3081 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_READ_CHAR_VAL,
3083 event_info->cb, event_info->user_data);
3086 g_free(info->handle);
3094 g_variant_unref(var);
3095 } else if (strcasecmp(signal_name, BT_OTP_NOTIFICATION_ENABLED) == 0) {
3096 BT_DBG("OTP Notification Enabled event");
3097 char *handle = NULL;
3099 /* Extract data from DBUS params */
3100 g_variant_get(parameters, "(i&s)", &result, &handle);
3101 BT_DBG("Handle [%s]", handle);
3102 BT_DBG("Result [%d]", result);
3104 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_NOTIFICATION_ENABLED,
3106 event_info->cb, event_info->user_data);
3107 } else if (strcasecmp(signal_name, BT_OTP_WRITE_CHAR_VAL) == 0) {
3108 BT_DBG("OTP Control point Activation result");
3109 char *handle = NULL;
3111 /* Extract data from DBUS params */
3112 g_variant_get(parameters, "(i&s)", &result, &handle);
3113 BT_DBG("Handle [%s]", handle);
3114 BT_DBG("Result [%d]", result);
3116 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_WRITE_CHAR_VAL,
3118 event_info->cb, event_info->user_data);
3119 } else if (strcasecmp(signal_name, BT_OTP_INDICATION) == 0) {
3120 BT_DBG("OTP Control point Indication Response");
3121 bluetooth_otp_resp_info_t *ind_res = NULL;
3122 char *buffer = NULL;
3123 GVariant *byte_var = NULL;
3124 char *handle = NULL;
3126 g_variant_get(parameters, "(i&s@ay)", &result, &handle, &byte_var);
3128 ind_res = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3129 ind_res->data_length = g_variant_get_size(byte_var);
3130 buffer = (char *)g_variant_get_data(byte_var);
3131 ind_res->data = g_memdup(buffer, ind_res->data_length);
3132 ind_res->handle = g_strdup(handle);
3134 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_INDICATION,
3136 event_info->cb, event_info->user_data);
3138 if (ind_res->handle) {
3139 g_free(ind_res->handle);
3142 if (ind_res->data) {
3143 g_free(ind_res->data);
3147 g_variant_unref(byte_var);
3153 static void __bt_remove_all_events(void)
3155 bt_event_info_t *info;
3157 while ((info = g_slist_nth_data(event_list, 0)) != NULL)
3158 _bt_unregister_event(info->event_type);
3161 g_slist_free(event_list);
3166 static gboolean __bt_event_is_registered(int event_type)
3169 bt_event_info_t *info;
3171 for (l = event_list; l != NULL; l = g_slist_next(l)) {
3176 if (info->event_type == event_type)
3183 bt_event_info_t *_bt_event_get_cb_data(int event_type)
3186 bt_event_info_t *info;
3188 for (l = event_list; l != NULL; l = g_slist_next(l)) {
3193 if (info->event_type == event_type)
3200 void _bt_add_server(int server_fd)
3202 bt_server_info_t *info;
3204 info = g_new0(bt_server_info_t, 1);
3205 info->server_fd = server_fd;
3207 server_list = g_slist_append(server_list, info);
3210 void _bt_remove_server(int server_fd)
3213 bt_server_info_t *info;
3215 for (l = server_list; l != NULL; l = g_slist_next(l)) {
3220 if (info->server_fd == server_fd)
3221 server_list = g_slist_remove(server_list, (void *)info);
3227 void _bt_set_obex_server_id(int server_type)
3229 obex_server_id = server_type;
3232 int _bt_get_obex_server_id(void)
3234 return obex_server_id;
3237 int _bt_init_event_handler(void)
3239 if (is_initialized == TRUE) {
3240 BT_ERR("Connection already exist");
3241 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3244 __bt_remove_all_events();
3246 is_initialized = TRUE;
3248 return BLUETOOTH_ERROR_NONE;
3251 int _bt_deinit_event_handler(void)
3253 if (is_initialized == FALSE) {
3254 BT_ERR("Connection dose not exist");
3255 return BLUETOOTH_ERROR_INTERNAL;
3258 __bt_remove_all_events();
3260 if (disable_timer_id > 0) {
3261 g_source_remove(disable_timer_id);
3262 disable_timer_id = 0;
3265 is_initialized = FALSE;
3267 return BLUETOOTH_ERROR_NONE;
3270 static void __bt_event_data_free(void *data)
3272 bt_event_info_t *cb_data = data;
3274 ret_if(cb_data == NULL);
3279 int _bt_register_event(int event_type, void *event_cb, void *user_data)
3281 GDBusConnection *connection_type;
3282 GDBusSignalCallback event_func;
3283 bt_event_info_t *cb_data;
3285 const char *interface = BT_EVENT_SERVICE;
3287 if (is_initialized == FALSE)
3288 _bt_init_event_handler();
3290 if (__bt_event_is_registered(event_type) == TRUE) {
3291 BT_ERR("The event is already registed");
3292 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3295 switch (event_type) {
3296 case BT_ADAPTER_EVENT:
3297 event_func = __bt_adapter_event_filter;
3298 path = BT_ADAPTER_PATH;
3300 case BT_LE_ADAPTER_EVENT:
3301 event_func = __bt_adapter_le_event_filter;
3302 path = BT_LE_ADAPTER_PATH;
3304 case BT_DEVICE_EVENT:
3305 event_func = __bt_device_event_filter;
3306 path = BT_DEVICE_PATH;
3309 event_func = __bt_hid_event_filter;
3312 case BT_HEADSET_EVENT:
3313 event_func = __bt_headset_event_filter;
3314 path = BT_HEADSET_PATH;
3316 case BT_NETWORK_EVENT:
3317 event_func = __bt_network_event_filter;
3318 path = BT_NETWORK_PATH;
3320 case BT_AVRCP_EVENT:
3321 event_func = __bt_avrcp_event_filter;
3322 path = BT_AVRCP_PATH;
3324 case BT_AVRCP_CONTROL_EVENT:
3325 event_func = __bt_avrcp_control_event_filter;
3326 path = BT_AVRCP_CONTROL_PATH;
3328 case BT_OPP_CLIENT_EVENT:
3329 event_func = __bt_opp_client_event_filter;
3330 path = BT_OPP_CLIENT_PATH;
3332 case BT_OPP_SERVER_EVENT:
3333 event_func = __bt_opp_server_event_filter;
3334 path = BT_OPP_SERVER_PATH;
3336 case BT_MAP_CLIENT_EVENT:
3337 event_func = __bt_map_client_event_filter;
3338 path = BT_MAP_CLIENT_PATH;
3340 case BT_PBAP_CLIENT_EVENT:
3341 event_func = __bt_pbap_client_event_filter;
3342 path = BT_PBAP_CLIENT_PATH;
3344 case BT_RFCOMM_CLIENT_EVENT:
3345 event_func = __bt_rfcomm_client_event_filter;
3346 path = BT_RFCOMM_CLIENT_PATH;
3348 case BT_RFCOMM_SERVER_EVENT:
3349 event_func = __bt_rfcomm_server_event_filter;
3350 path = BT_RFCOMM_SERVER_PATH;
3352 case BT_HF_AGENT_EVENT:
3353 BT_DBG("BT_HF_AGENT_EVENT\n");
3354 event_func = __bt_hf_agent_event_filter;
3355 path = BT_HF_AGENT_PATH;
3356 interface = BT_HF_SERVICE_INTERFACE;
3358 case BT_A2DP_SOURCE_EVENT:
3359 BT_DBG("BT_A2DP_SOURCE_EVENT");
3360 event_func = __bt_a2dp_source_event_filter;
3361 path = BT_A2DP_SOURCE_PATH;
3363 case BT_HID_DEVICE_EVENT:
3364 BT_DBG("BT_HID_DEVICE_EVENT");
3365 event_func = __bt_hid_device_event_filter;
3366 path = BT_HID_DEVICE_PATH;
3368 case BT_GATT_BLUEZ_EVENT:
3369 BT_DBG("BT_GATT_BLUEZ_EVENT");
3370 event_func = __bt_device_event_filter;
3371 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
3375 BT_DBG("BT_TDS_EVENT");
3376 event_func = __bt_tds_event_filter;
3380 BT_DBG("BT_OTP_EVENT");
3381 event_func = __bt_otp_event_filter;
3385 BT_ERR("Unknown event");
3386 return BLUETOOTH_ERROR_INTERNAL;
3389 connection_type = _bt_gdbus_get_system_gconn();
3390 if (connection_type == NULL)
3391 return BLUETOOTH_ERROR_INTERNAL;
3393 cb_data = g_new0(bt_event_info_t, 1);
3395 cb_data->event_type = event_type;
3396 cb_data->cb = event_cb;
3397 cb_data->user_data = user_data;
3399 cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
3400 NULL, interface, NULL, path, NULL, 0,
3401 event_func, cb_data, NULL);
3403 event_list = g_slist_append(event_list, cb_data);
3405 return BLUETOOTH_ERROR_NONE;
3408 int _bt_unregister_event(int event_type)
3410 GDBusConnection *connection_type;
3411 bt_event_info_t *cb_data;
3413 if (is_initialized == FALSE) {
3414 BT_ERR("Event is not registered");
3415 return BLUETOOTH_ERROR_NOT_INITIALIZED;
3418 if (__bt_event_is_registered(event_type) == FALSE) {
3419 BT_ERR("Not registered event");
3420 return BLUETOOTH_ERROR_INTERNAL;
3423 cb_data = _bt_event_get_cb_data(event_type);
3425 if (cb_data == NULL) {
3426 BT_ERR("No matched event data");
3427 return BLUETOOTH_ERROR_INTERNAL;
3430 connection_type = _bt_gdbus_get_system_gconn();
3432 event_list = g_slist_remove(event_list, (void *)cb_data);
3434 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
3436 g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
3438 __bt_event_data_free((void *)cb_data);
3440 return BLUETOOTH_ERROR_NONE;
3443 static void __bt_name_owner_changed(GDBusConnection *connection,
3444 const gchar *sender_name,
3445 const gchar *object_path,
3446 const gchar *interface_name,
3447 const gchar *signal_name,
3448 GVariant *parameters,
3451 const char *name = NULL;
3452 const char *old_owner = NULL;
3453 const char *new_owner = NULL;
3454 bt_event_info_t *event_info;
3456 g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
3458 if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
3459 (new_owner != NULL && *new_owner == '\0')) {
3460 BT_DBG("bt-service is terminated");
3461 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
3462 if (event_info == NULL)
3465 if (disable_timer_id > 0)
3466 g_source_remove(disable_timer_id);
3468 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
3469 (GSourceFunc)__bt_reliable_disable_cb,
3474 void _bt_register_name_owner_changed(void)
3476 GDBusConnection *connection_type;
3478 connection_type = _bt_gdbus_get_system_gconn();
3479 if (connection_type == NULL) {
3480 BT_ERR("Unable to get the bus");
3483 owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
3484 NULL, BT_EVENT_FREEDESKTOP,
3485 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
3486 __bt_name_owner_changed, NULL, NULL);
3489 void _bt_unregister_name_owner_changed(void)
3491 GDBusConnection *connection_type;
3493 connection_type = _bt_gdbus_get_system_gconn();
3494 if (connection_type != NULL && owner_sig_id != -1) {
3495 g_dbus_connection_signal_unsubscribe(connection_type,
3501 static void __bt_manager_event_filter(GDBusConnection *connection,
3502 const gchar *sender_name,
3503 const gchar *object_path,
3504 const gchar *interface_name,
3505 const gchar *signal_name,
3506 GVariant *parameters,
3510 GVariantIter *interface_iter = NULL;
3511 char *interface_str = NULL;
3512 bt_gatt_service_change_t change;
3513 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
3514 char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
3515 bt_user_info_t *user_info = NULL;
3517 if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
3518 g_variant_get(parameters, "(&s)", &path);
3520 _bt_convert_device_path_to_address(path, address);
3521 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
3522 _bt_convert_addr_string_to_secure_string(secure_address, address);
3524 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
3526 BT_INFO("GATT Service [%s] added, but no watcher for %s",
3527 path, secure_address);
3530 BT_INFO(" ### GATT Service added [%s] [%s]",
3531 path, secure_address);
3533 change.svc_path = g_strdup(path);
3534 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
3536 user_info = _bt_get_user_data(BT_COMMON);
3537 if (user_info != NULL) {
3538 _bt_common_event_cb(
3539 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
3540 BLUETOOTH_ERROR_NONE, &change,
3541 user_info->cb, user_info->user_data);
3544 g_free(change.svc_path);
3545 } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
3546 g_variant_get(parameters, "(&oas)",
3547 &path, &interface_iter);
3550 BT_ERR("Invalid adapter path");
3554 _bt_convert_device_path_to_address(path, address);
3555 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
3556 _bt_convert_addr_string_to_secure_string(secure_address, address);
3558 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
3560 BT_INFO("GATT Service [%s] removed, but no watcher for %s",
3561 path, secure_address);
3565 while (g_variant_iter_loop(interface_iter, "s", &interface_str)) {
3566 if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) == 0) {
3567 change.svc_path = g_strdup(path);
3568 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
3570 BT_INFO(" ### GATT Service removed [%s] [%s]",
3571 path, secure_address);
3573 user_info = _bt_get_user_data(BT_COMMON);
3574 if (user_info != NULL) {
3575 _bt_common_event_cb(
3576 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
3577 BLUETOOTH_ERROR_NONE, &change,
3578 user_info->cb, user_info->user_data);
3581 g_free(change.svc_path);
3585 g_variant_iter_free(interface_iter);
3589 int _bt_register_manager_subscribe_signal(gboolean subscribe)
3591 GDBusConnection *g_conn;
3592 static int service_added_id = -1;
3593 static int interface_removed_id = -1;
3595 g_conn = _bt_gdbus_get_system_gconn();
3597 return BLUETOOTH_ERROR_INTERNAL;
3599 if (subscribe == TRUE) {
3600 if (service_added_id == -1) {
3601 service_added_id = g_dbus_connection_signal_subscribe(g_conn,
3602 NULL, GATT_SERV_INTERFACE,
3603 "GattServiceAdded", NULL, NULL, 0,
3604 __bt_manager_event_filter,
3607 if (interface_removed_id == -1) {
3608 interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
3609 NULL, BT_MANAGER_INTERFACE,
3610 "InterfacesRemoved", NULL, NULL, 0,
3611 __bt_manager_event_filter,
3615 if (service_added_id != -1) {
3616 g_dbus_connection_signal_unsubscribe(g_conn,
3618 service_added_id = -1;
3620 if (interface_removed_id != -1) {
3621 g_dbus_connection_signal_unsubscribe(g_conn,
3622 interface_removed_id);
3623 interface_removed_id = -1;
3627 return BLUETOOTH_ERROR_NONE;