2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <dbus/dbus.h>
24 #include "bluetooth-api.h"
25 #include "bluetooth-audio-api.h"
26 #include "bluetooth-hid-api.h"
27 #include "bt-internal-types.h"
28 #include "bluetooth-media-control.h"
30 #include "bt-common.h"
31 #include "bt-event-handler.h"
32 #include "bt-gatt-client.h"
33 #include "bt-request-sender.h"
35 #define PROFILE_SUPPORTED 0x3 /* This corresponds to binary 0b11*/
36 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
46 static int obex_server_id;
47 static guint disable_timer_id;
48 static gboolean is_initialized;
49 static GSList *sending_list = NULL;
50 static GSList *server_list = NULL;
51 static GSList *event_list = NULL;
52 static int owner_sig_id = -1;
54 void _bt_add_push_request_id(int request_id)
56 bt_sending_info_t *info;
58 info = g_new0(bt_sending_info_t, 1);
59 info->request_id = request_id;
61 sending_list = g_slist_append(sending_list, info);
64 static gboolean __bt_is_request_id_exist(int request_id)
67 bt_sending_info_t *info;
69 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
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 /* Fix : NULL_RETURNS */
233 retv_if(call_status == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
235 call_status->number = g_strdup(number);
236 call_status->direction = dir;
237 call_status->status = status;
238 call_status->mpart = mpart;
239 call_status->idx = idx;
240 handle->list = g_list_append(handle->list, (gpointer)call_status);
241 return BLUETOOTH_ERROR_NONE;
244 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
246 bluetooth_device_info_t *dev_info;
247 const char *address = NULL;
248 const char *name = NULL;
249 gchar **uuids = NULL;
250 unsigned int dev_class = 0;
252 gboolean paired = FALSE;
254 gboolean trust = FALSE;
256 int result = BLUETOOTH_ERROR_NONE;
257 GVariant *string_var;
259 int manufacturer_data_len = 0;
260 GVariant *manufacturer_var = NULL;
261 const char *manufacturer_data = NULL;
263 g_variant_get(parameters, "(isunsbub@asn@ay)", &result, &address,
264 &dev_class, &rssi, &name, &paired,
265 &connected, &trust, &string_var, &manufacturer_data_len, &manufacturer_var);
267 if (string_var == NULL) {
268 BT_ERR("invalid parameters in signal");
272 uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
274 len = g_variant_get_size(manufacturer_var);
276 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
278 dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
279 /* Fix : NULL_RETURNS */
280 if (dev_info == NULL) {
281 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
285 dev_info->rssi = rssi;
286 dev_info->paired = paired;
287 dev_info->connected = connected;
288 dev_info->trust = trust;
290 g_strlcpy(dev_info->device_name.name, name,
291 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
293 _bt_divide_device_class(&dev_info->device_class, dev_class);
295 _bt_convert_addr_string_to_type(dev_info->device_address.addr,
299 __bt_get_uuid_info(dev_info, uuids, uuid_count);
301 if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
302 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
303 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
305 dev_info->manufacturer_data.data_len = manufacturer_data_len;
306 if (manufacturer_data)
307 for (i = 0; i < manufacturer_data_len; i++)
308 dev_info->manufacturer_data.data[i] = manufacturer_data[i];
312 g_variant_unref(string_var);
313 g_variant_unref(manufacturer_var);
317 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
319 bluetooth_le_device_info_t *le_dev_info;
320 const char *address = NULL;
325 int adv_data_len = 0;
326 GVariant *adv_var = NULL;
327 const char *adv_data = NULL;
328 int scan_data_len = 0;
329 GVariant *scan_var = NULL;
330 const char *scan_data = NULL;
331 int result = BLUETOOTH_ERROR_NONE;
333 g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
334 &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
336 len = g_variant_get_size(adv_var);
338 adv_data = (char *)g_variant_get_data(adv_var);
340 len = g_variant_get_size(scan_var);
342 scan_data = (char *)g_variant_get_data(scan_var);
344 le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
345 /* Fix : NULL_RETURNS */
346 if (le_dev_info == NULL) {
347 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
350 _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
351 le_dev_info->addr_type = addr_type;
352 le_dev_info->rssi = rssi;
353 le_dev_info->adv_ind_data.data_len = adv_data_len;
355 for (i = 0; i < adv_data_len; i++)
357 le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
359 le_dev_info->scan_resp_data.data_len = scan_data_len;
361 for (i = 0; i < scan_data_len; i++)
363 le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
368 g_variant_unref(adv_var);
369 g_variant_unref(scan_var);
373 gboolean __bt_reliable_disable_cb(gpointer user_data)
376 bt_event_info_t *event_info = user_data;
378 _bt_set_le_scan_status(FALSE);
380 _bt_set_adapter_internal_status(FALSE);
382 if (is_initialized != FALSE) {
383 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
384 BLUETOOTH_ERROR_NONE, NULL,
385 event_info->cb, event_info->user_data);
388 obex_server_id = BT_NO_SERVER;
389 __bt_remove_all_server();
390 __bt_remove_all_push_request_id();
392 _bt_rfcomm_server_free_all();
395 _bluetooth_hid_free_hid_info();
401 void __bt_adapter_event_filter(GDBusConnection *connection,
402 const gchar *sender_name,
403 const gchar *object_path,
404 const gchar *interface_name,
405 const gchar *signal_name,
406 GVariant *parameters,
409 bt_event_info_t *event_info;
410 int result = BLUETOOTH_ERROR_NONE;
412 event_info = (bt_event_info_t *)user_data;
413 ret_if(event_info == NULL);
415 if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
417 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
420 if (strcasecmp(signal_name, BT_ENABLED) == 0) {
421 BT_INFO("BT_ENABLED");
422 g_variant_get(parameters, "(i)", &result);
424 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
426 event_info->cb, event_info->user_data);
427 } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
428 BT_INFO("BT_DISABLED");
430 /* Wait for the termining time of bt-service */
431 if (disable_timer_id > 0)
432 g_source_remove(disable_timer_id);
434 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
435 (GSourceFunc)__bt_reliable_disable_cb,
437 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
440 g_variant_get(parameters, "(in)", &result, &mode);
441 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
443 event_info->cb, event_info->user_data);
444 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
447 g_variant_get(parameters, "(in)", &result, &timeout);
448 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
450 event_info->cb, event_info->user_data);
451 } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
452 gboolean connectable = FALSE;
454 g_variant_get(parameters, "(b)", &connectable);
455 BT_DBG("Connectable is changed : %d", connectable);
457 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
458 result, &connectable,
459 event_info->cb, event_info->user_data);
460 } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
461 char *adapter_name = NULL;
463 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
464 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
465 result, adapter_name,
466 event_info->cb, event_info->user_data);
467 } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
468 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
469 BLUETOOTH_ERROR_NONE, NULL,
470 event_info->cb, event_info->user_data);
471 } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
472 g_variant_get(parameters, "(i)", &result);
473 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
475 event_info->cb, event_info->user_data);
476 } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
479 g_variant_get(parameters, "(ii)", &result, &adv_handle);
480 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
482 event_info->cb, event_info->user_data);
483 } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
486 g_variant_get(parameters, "(ii)", &result, &adv_handle);
487 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
489 event_info->cb, event_info->user_data);
490 } else if (strcasecmp(signal_name, BT_ADVERTISING_MANUFACTURER_DATA_CHANGED) == 0) {
491 GVariant *var = NULL;
495 g_variant_get(parameters, "(@ay)", &var);
496 len = g_variant_get_size(var);
497 data = (char *)g_variant_get_data(var);
499 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
501 event_info->cb, event_info->user_data);
503 g_variant_unref(var);
504 } else if (strcasecmp(signal_name, BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
505 GVariant *var = NULL;
509 g_variant_get(parameters, "(@ay)", &var);
510 len = g_variant_get_size(var);
511 data = (char *)g_variant_get_data(var);
513 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
515 event_info->cb, event_info->user_data);
517 g_variant_unref(var);
518 } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
519 GVariant *var = NULL;
523 g_variant_get(parameters, "(@ay)", &var);
524 len = g_variant_get_size(var);
525 data = (char *)g_variant_get_data(var);
527 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
529 event_info->cb, event_info->user_data);
531 g_variant_unref(var);
532 } else if (strcasecmp(signal_name, BT_PASSKEY_NOTIFICATION) == 0) {
533 const char *address = NULL;
534 const char *passkey = NULL;
535 const char *passkey_info[2];
537 g_variant_get(parameters, "(&s&s)", &address, &passkey);
538 passkey_info[0] = address;
539 passkey_info[1] = passkey;
541 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_NOTIFICATION,
542 BLUETOOTH_ERROR_NONE, (void*)passkey_info,
543 event_info->cb, event_info->user_data);
544 } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 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 if (strlen(device_info->device_name.name) > 0)
553 event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
555 event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
557 _bt_common_event_cb(event,
559 event_info->cb, event_info->user_data);
562 } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
563 bluetooth_device_info_t *device_info;
565 device_info = __bt_get_device_info_in_message(parameters,
567 ret_if(device_info == NULL);
569 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
571 event_info->cb, event_info->user_data);
574 } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
575 const char *address = NULL;
576 bluetooth_device_address_t dev_address = { {0} };
578 g_variant_get(parameters, "(i&s)", &result, &address);
580 _bt_convert_addr_string_to_type(dev_address.addr,
583 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
584 result, &dev_address,
585 event_info->cb, event_info->user_data);
586 } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
587 bluetooth_device_info_t *device_info;
588 bt_sdp_info_t sdp_info;
590 device_info = __bt_get_device_info_in_message(parameters,
592 ret_if(device_info == NULL);
594 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
596 sdp_info.service_index = device_info->service_index;
598 memcpy(&sdp_info.device_addr,
599 &device_info->device_address,
600 BLUETOOTH_ADDRESS_LENGTH);
602 memcpy(sdp_info.service_list_array,
603 device_info->service_list_array,
604 BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
606 memcpy(sdp_info.uuids,
608 BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
610 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
612 event_info->cb, event_info->user_data);
615 } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
616 gboolean ipsp_intialized = FALSE;
617 g_variant_get(parameters, "(b)", &ipsp_intialized);
619 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
621 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
622 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
623 event_info->cb, event_info->user_data);
624 } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
625 const char *address = NULL;
626 const char *name = NULL;
627 const char *str_passkey = NULL;
629 bluetooth_authentication_request_info_t auth_info;
630 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
632 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
634 g_strlcpy(auth_info.device_name.name, name,
635 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
636 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
638 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
640 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
642 event_info->cb, event_info->user_data);
643 } else if (strcasecmp(signal_name, BT_PIN_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_PIN_REQUEST,
659 event_info->cb, event_info->user_data);
660 } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
661 const char *address = NULL;
662 const char *name = NULL;
664 bluetooth_authentication_request_info_t auth_info;
665 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
667 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
669 g_strlcpy(auth_info.device_name.name, name,
670 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
671 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
674 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
676 event_info->cb, event_info->user_data);
677 } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
678 const char *address = NULL;
679 const char *name = NULL;
680 const char *str_passkey = NULL;
682 bluetooth_authentication_request_info_t auth_info;
683 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
685 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
687 g_strlcpy(auth_info.device_name.name, name,
688 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
689 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
691 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
693 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
695 event_info->cb, event_info->user_data);
699 void __bt_adapter_le_event_filter(GDBusConnection *connection,
700 const gchar *sender_name,
701 const gchar *object_path,
702 const gchar *interface_name,
703 const gchar *signal_name,
704 GVariant *parameters,
707 bt_event_info_t *event_info;
708 int result = BLUETOOTH_ERROR_NONE;
710 event_info = (bt_event_info_t *)user_data;
711 ret_if(event_info == NULL);
713 if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
715 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
718 if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
719 BT_INFO("BT_LE_ENABLED");
720 g_variant_get(parameters, "(i)", &result);
721 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
723 event_info->cb, event_info->user_data);
724 } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
725 BT_INFO("BT_LE_DISABLED");
726 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
728 event_info->cb, event_info->user_data);
729 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
730 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
731 BLUETOOTH_ERROR_NONE, NULL,
732 event_info->cb, event_info->user_data);
733 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
734 g_variant_get(parameters, "(i)", &result);
735 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
737 event_info->cb, event_info->user_data);
738 } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
739 bluetooth_le_device_info_t *le_device_info;
741 le_device_info = __bt_get_le_device_info_in_message(parameters,
743 ret_if(le_device_info == NULL);
745 if (bluetooth_is_le_scanning() == TRUE) {
746 _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
747 result, le_device_info,
748 event_info->cb, event_info->user_data);
751 g_free(le_device_info);
755 void __bt_device_event_filter(GDBusConnection *connection,
756 const gchar *sender_name,
757 const gchar *object_path,
758 const gchar *interface_name,
759 const gchar *signal_name,
760 GVariant *parameters,
763 bt_event_info_t *event_info;
764 int result = BLUETOOTH_ERROR_NONE;
766 event_info = (bt_event_info_t *)user_data;
767 ret_if(event_info == NULL);
770 gboolean gatt_interface = FALSE;
772 if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
773 gatt_interface = TRUE;
775 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
776 gatt_interface == FALSE)
778 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
779 gatt_interface == FALSE)
782 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0)
784 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
788 ret_if(signal_name == NULL);
790 if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
791 const char *address = NULL;
792 bluetooth_device_address_t dev_address = { {0} };
793 BT_DBG("BT_GATT_CONNECTED");
794 g_variant_get(parameters, "(i&s)", &result, &address);
796 _bt_convert_addr_string_to_type(dev_address.addr, address);
797 BT_DBG("Sending Event to Framework");
798 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
799 result, &dev_address,
800 event_info->cb, event_info->user_data);
801 } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
802 const char *address = NULL;
803 bluetooth_device_address_t dev_address = { {0} };
804 BT_DBG("BT_GATT_DISCONNECTED");
805 g_variant_get(parameters, "(i&s)", &result, &address);
807 _bt_convert_addr_string_to_type(dev_address.addr, address);
808 BT_DBG("Sending Event to Framework");
809 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
810 result, &dev_address,
811 event_info->cb, event_info->user_data);
812 } else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
813 const char *address = NULL;
814 bluetooth_device_address_t dev_address = { {0} };
815 bluetooth_le_att_mtu_info_t att_mtu_info;
818 BT_DBG("BT_GATT_REQ_ATT_MTU_CHANGED");
819 g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
821 _bt_convert_addr_string_to_type(dev_address.addr, address);
823 memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
824 memcpy(att_mtu_info.device_address.addr,
826 BLUETOOTH_ADDRESS_LENGTH);
828 att_mtu_info.mtu = mtu;
829 att_mtu_info.status = status;
831 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
832 result, &att_mtu_info,
833 event_info->cb, event_info->user_data);
835 } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
837 } else if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) {
839 const char *char_handle = NULL;
841 const char * value = NULL;
842 GVariant *char_value_var = NULL;
843 bt_gatt_char_value_t char_val = { 0, };
844 BT_DBG("BT_GATT_CHAR_VAL_CHANGED");
846 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
848 len = g_variant_get_size(char_value_var);
849 ret_if(char_value_var == NULL);
852 value = (char *)g_variant_get_data(char_value_var);
854 char_val.char_handle = g_strdup(char_handle);
855 char_val.val_len = len;
856 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
857 if (char_val.val_len > 0 && value != NULL) {
858 char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
859 /* Fix : NULL_RETURNS */
860 if (char_val.char_value == NULL) {
861 BT_ERR("BLUETOOTH_ERROR_OUT_OF_MEMORY");
862 g_free(char_val.char_handle);
863 g_variant_unref(char_value_var);
866 memcpy(char_val.char_value, value, len);
867 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
869 event_info->cb, event_info->user_data);
870 g_free(char_val.char_value);
871 g_variant_unref(char_value_var);
873 g_free(char_val.char_handle);
874 } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
875 const char *address = NULL;
876 unsigned char addr_type;
877 bt_connection_info_t conn_info;
878 bluetooth_device_address_t dev_address = { {0} };
879 BT_DBG("BT_DEVICE_CONNECTED");
880 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
882 _bt_convert_addr_string_to_type(dev_address.addr,
885 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
887 memcpy(conn_info.device_addr.addr,
889 BLUETOOTH_ADDRESS_LENGTH);
891 conn_info.addr_type = addr_type;
892 conn_info.disc_reason = 0;
893 BT_DBG("Sending Event to Framework");
894 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
896 event_info->cb, event_info->user_data);
898 } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
899 const char *address = NULL;
900 unsigned char addr_type;
901 bt_connection_info_t conn_info;
902 bluetooth_device_address_t dev_address = { {0} };
903 BT_DBG("BT_DEVICE_DISCONNECTED");
904 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
906 _bt_convert_addr_string_to_type(dev_address.addr,
909 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
911 memcpy(conn_info.device_addr.addr,
913 BLUETOOTH_ADDRESS_LENGTH);
915 conn_info.addr_type = addr_type;
916 conn_info.disc_reason = result;
917 BT_DBG("Sending Event to Framework");
918 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
920 event_info->cb, event_info->user_data);
922 } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
923 bt_rssi_enabled_t enabled = { 0, };
926 gboolean rssi_enabled = FALSE;
928 g_variant_get(parameters, "(isib)", &result, &address,
929 &link_type, &rssi_enabled);
931 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
932 address, link_type, rssi_enabled);
933 enabled.address = address;
934 enabled.link_type = link_type;
935 enabled.rssi_enabled = rssi_enabled;
937 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
939 event_info->cb, event_info->user_data);
940 } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
945 bt_rssi_alert_t alert = { 0, };
947 g_variant_get(parameters, "(isiii)", &result, &address,
948 &link_type, &alert_type, &rssi_dbm);
950 alert.alert_type = alert_type;
951 alert.rssi_dbm = rssi_dbm;
952 alert.address = address;
953 alert.link_type = link_type;
954 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
955 address, link_type, alert_type, rssi_dbm);
956 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
958 event_info->cb, event_info->user_data);
959 } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
963 bt_raw_rssi_t raw_rssi = { 0, };
965 g_variant_get(parameters, "(isii)", &result,
966 &address, &link_type, &rssi_dbm);
968 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
969 address, link_type, rssi_dbm);
971 raw_rssi.rssi_dbm = rssi_dbm;
972 raw_rssi.address = address;
973 raw_rssi.link_type = link_type;
975 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
977 event_info->cb, event_info->user_data);
978 } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
979 const char *address = NULL;
980 bluetooth_device_address_t dev_address = { {0} };
982 g_variant_get(parameters, "(i&s)", &result, &address);
984 _bt_convert_addr_string_to_type(dev_address.addr,
987 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
988 result, &dev_address,
989 event_info->cb, event_info->user_data);
990 } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
991 const char *address = NULL;
992 bluetooth_device_address_t dev_address = { {0} };
994 g_variant_get(parameters, "(i&s)", &result, &address);
996 _bt_convert_addr_string_to_type(dev_address.addr,
999 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
1000 result, &dev_address,
1001 event_info->cb, event_info->user_data);
1002 } else if (strcasecmp(signal_name, BT_SUPPORTED_PROFILE_TRUSTED) == 0) {
1004 bt_supported_profile_trusted_t profile_info = { 0, };
1007 g_variant_get(parameters, "(i&si)", &result,
1010 BT_DBG("Address [%s] trust[%d]", address, trust);
1011 profile_info.address = address;
1012 if (trust & (PROFILE_SUPPORTED << 0)) { /* Bit 0 & 1 - for PBAP Supported */
1013 profile_info.profile = TRUSTED_PROFILE_PBAP;
1014 profile_info.supported = TRUE;
1015 if (trust & (1 << 1)) /* Bit 1 - for PBAP Trusted */
1016 profile_info.trusted = TRUE;
1018 profile_info.trusted = FALSE;
1020 _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1021 result, &profile_info,
1022 event_info->cb, event_info->user_data);
1024 if (trust & (PROFILE_SUPPORTED << 2)) { /* Bit 2 & 3 - for MAP Supported */
1025 profile_info.profile = TRUSTED_PROFILE_MAP;
1026 profile_info.supported = TRUE;
1027 if (trust & (1 << 3)) /* Bit 3 - for PBAP Trusted */
1028 profile_info.trusted = TRUE;
1030 profile_info.trusted = FALSE;
1032 _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1033 result, &profile_info,
1034 event_info->cb, event_info->user_data);
1036 if (trust & (PROFILE_SUPPORTED << 4)) { /* Bit 4 & 5- for SAP Supported */
1037 profile_info.profile = TRUSTED_PROFILE_SAP;
1038 profile_info.supported = TRUE;
1039 if (trust & (1 << 5)) /* Bit 5 - for SAP Trusted */
1040 profile_info.trusted = TRUE;
1042 profile_info.trusted = FALSE;
1044 _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1045 result, &profile_info,
1046 event_info->cb, event_info->user_data);
1048 } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1049 const char *address = NULL;
1050 const char *if_name = NULL;
1051 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1052 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1054 BT_DBG("BT_IPSP_CONNECTED");
1055 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1057 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1058 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1060 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1061 result, &bt_ipsp_iface_info,
1062 event_info->cb, event_info->user_data);
1063 } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1064 const char *address = NULL;
1065 const char *if_name = NULL;
1066 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1067 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1069 BT_DBG("BT_IPSP_DISCONNECTED");
1070 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1072 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1073 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1075 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1076 result, &bt_ipsp_iface_info,
1077 event_info->cb, event_info->user_data);
1078 } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1079 const char *address = NULL;
1080 bluetooth_device_address_t dev_address = { {0} };
1085 bt_le_data_length_params_t params;
1087 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1089 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1090 tx_octets, tx_time, rx_octets, rx_time);
1092 params.max_tx_octets = tx_octets;
1093 params.max_tx_time = tx_time;
1094 params.max_rx_octets = rx_octets;
1095 params.max_rx_time = rx_time;
1097 _bt_convert_addr_string_to_type(dev_address.addr, address);
1099 memcpy(¶ms.device_address,
1100 &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1102 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1103 result, ¶ms, event_info->cb, event_info->user_data);
1104 } else if (strcasecmp(signal_name, BT_PXP_PROPERTY_CHANGED) == 0) {
1105 const char *address = NULL;
1106 bluetooth_device_address_t dev_address = { {0} };
1107 int role, type, level;
1108 bt_pxp_property_changed_params_t params;
1110 BT_DBG("BT_PXP_PROPERTY_CHANGED");
1112 g_variant_get(parameters, "(isiii)", &result, &address, &role, &type, &level);
1114 _bt_convert_addr_string_to_type(dev_address.addr, address);
1115 memcpy(¶ms.device_address, &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1117 params.service_type = type;
1118 params.alert_lvl = level;
1120 _bt_common_event_cb(BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
1121 result, ¶ms, event_info->cb, event_info->user_data);
1125 void __bt_hid_event_filter(GDBusConnection *connection,
1126 const gchar *sender_name,
1127 const gchar *object_path,
1128 const gchar *interface_name,
1129 const gchar *signal_name,
1130 GVariant *parameters,
1133 bt_event_info_t *event_info;
1134 int result = BLUETOOTH_ERROR_NONE;
1136 event_info = (bt_event_info_t *)user_data;
1137 ret_if(event_info == NULL);
1139 if (strcasecmp(object_path, BT_HID_PATH) != 0)
1141 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1144 ret_if(signal_name == NULL);
1146 if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1147 const char *address = NULL;
1148 bluetooth_device_address_t dev_address = { {0} };
1150 g_variant_get(parameters, "(i&s)", &result, &address);
1152 _bt_convert_addr_string_to_type(dev_address.addr,
1155 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1156 result, &dev_address,
1157 event_info->cb, event_info->user_data);
1158 } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1159 const char *address = NULL;
1160 bluetooth_device_address_t dev_address = { {0} };
1162 g_variant_get(parameters, "(i&s)", &result, &address);
1164 BT_DBG("address: %s", address);
1166 _bt_convert_addr_string_to_type(dev_address.addr,
1169 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1170 result, &dev_address,
1171 event_info->cb, event_info->user_data);
1175 void __bt_headset_event_filter(GDBusConnection *connection,
1176 const gchar *sender_name,
1177 const gchar *object_path,
1178 const gchar *interface_name,
1179 const gchar *signal_name,
1180 GVariant *parameters,
1183 bt_event_info_t *event_info;
1184 int result = BLUETOOTH_ERROR_NONE;
1185 event_info = (bt_event_info_t *)user_data;
1186 ret_if(event_info == NULL);
1188 if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1190 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1193 ret_if(signal_name == NULL);
1195 if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1196 char *address = NULL;
1198 g_variant_get(parameters, "(i&s)", &result, &address);
1200 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1202 event_info->cb, event_info->user_data);
1203 } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1204 char *address = NULL;
1206 g_variant_get(parameters, "(i&s)", &result, &address);
1208 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1210 event_info->cb, event_info->user_data);
1211 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1212 char *address = NULL;
1214 g_variant_get(parameters, "(i&s)", &result, &address);
1216 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1218 event_info->cb, event_info->user_data);
1219 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1220 char *address = NULL;
1222 g_variant_get(parameters, "(i&s)", &result, &address);
1224 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1226 event_info->cb, event_info->user_data);
1227 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1228 char *address = NULL;
1230 g_variant_get(parameters, "(i&s)", &result, &address);
1231 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1233 event_info->cb, event_info->user_data);
1234 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1235 char *address = NULL;
1237 g_variant_get(parameters, "(i&s)", &result, &address);
1239 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1241 event_info->cb, event_info->user_data);
1242 } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1245 char *address = NULL;
1247 g_variant_get(parameters, "(i&sq)", &result, &address,
1249 gain = (unsigned int)spkr_gain;
1251 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1253 event_info->cb, event_info->user_data);
1254 } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1257 char *address = NULL;
1259 g_variant_get(parameters, "(i&sq)", &result,
1260 &address, &mic_gain);
1261 gain = (unsigned int)mic_gain;
1263 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1265 event_info->cb, event_info->user_data);
1269 void __bt_hid_device_event_filter(GDBusConnection *connection,
1270 const gchar *sender_name,
1271 const gchar *object_path,
1272 const gchar *interface_name,
1273 const gchar *signal_name,
1274 GVariant *parameters,
1277 bt_event_info_t *event_info;
1278 int result = BLUETOOTH_ERROR_NONE;
1280 event_info = (bt_event_info_t *)user_data;
1281 ret_if(event_info == NULL);
1282 if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1284 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1287 ret_if(signal_name == NULL);
1289 if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1290 const char *address = NULL;
1291 bluetooth_device_address_t dev_address = { {0} };
1293 g_variant_get(parameters, "(i&s)", &result, &address);
1295 _bt_convert_addr_string_to_type(dev_address.addr,
1298 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1299 result, &dev_address,
1300 event_info->cb, event_info->user_data);
1301 } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1302 const char *address = NULL;
1303 bluetooth_device_address_t dev_address = { {0} };
1305 g_variant_get(parameters, "(i&s)", &result, &address);
1307 BT_DBG("address: %s", address);
1309 _bt_convert_addr_string_to_type(dev_address.addr,
1312 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1313 result, &dev_address,
1314 event_info->cb, event_info->user_data);
1315 } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_CONNECTED) == 0) {
1316 BT_INFO_C("Type %s", g_variant_get_type_string(parameters));
1317 const char *address = NULL;
1318 bluetooth_device_address_t dev_address = { {0} };
1320 g_variant_get(parameters, "(i&s)", &result, &address);
1322 BT_DBG("address: %s", address);
1323 _bt_convert_addr_string_to_type(dev_address.addr,
1325 int ctrl = -1, intr = -1;
1326 _bt_hid_device_get_fd(address, &ctrl, &intr);
1327 if (ctrl != -1 && intr != -1) {
1328 new_hid_connection(NULL, ctrl, &dev_address);
1329 new_hid_connection(NULL, intr, &dev_address);
1331 } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_DISCONNECTED) == 0) {
1332 const char *address = NULL;
1333 g_variant_get(parameters, "(i&s)", &result, &address);
1335 BT_DBG("address: %s", address);
1338 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1339 const gchar *sender_name,
1340 const gchar *object_path,
1341 const gchar *interface_name,
1342 const gchar *signal_name,
1343 GVariant *parameters,
1346 bt_event_info_t *event_info;
1347 int result = BLUETOOTH_ERROR_NONE;
1348 event_info = (bt_event_info_t *)user_data;
1349 ret_if(event_info == NULL);
1351 if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1353 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1356 ret_if(signal_name == NULL);
1358 if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1359 char *address = NULL;
1361 g_variant_get(parameters, "(i&s)", &result, &address);
1362 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1364 event_info->cb, event_info->user_data);
1365 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1366 char *address = NULL;
1368 g_variant_get(parameters, "(i&s)", &result, &address);
1370 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1372 event_info->cb, event_info->user_data);
1376 void __bt_network_event_filter(GDBusConnection *connection,
1377 const gchar *sender_name,
1378 const gchar *object_path,
1379 const gchar *interface_name,
1380 const gchar *signal_name,
1381 GVariant *parameters,
1384 bt_event_info_t *event_info;
1385 int result = BLUETOOTH_ERROR_NONE;
1386 event_info = (bt_event_info_t *)user_data;
1387 ret_if(event_info == NULL);
1389 if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1391 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1394 ret_if(signal_name == NULL);
1396 if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1397 const char *address = NULL;
1398 bluetooth_device_address_t dev_address = { {0} };
1400 g_variant_get(parameters, "(i&s)", &result, &address);
1402 _bt_convert_addr_string_to_type(dev_address.addr,
1405 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1406 result, &dev_address,
1407 event_info->cb, event_info->user_data);
1408 } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1409 const char *address = NULL;
1410 bluetooth_device_address_t dev_address = { {0} };
1412 g_variant_get(parameters, "(i&s)", &result, &address);
1414 _bt_convert_addr_string_to_type(dev_address.addr,
1417 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1418 result, &dev_address,
1419 event_info->cb, event_info->user_data);
1420 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1421 const char *device = NULL;
1422 const char *address = NULL;
1423 bluetooth_network_device_info_t network_info;
1425 g_variant_get(parameters, "(i&s&s)", &result,
1428 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1430 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1433 _bt_print_device_address_t(&network_info.device_address);
1434 g_strlcpy(network_info.interface_name, device,
1435 sizeof(network_info.interface_name));
1437 DBG_SECURE("Interface: %s", network_info.interface_name);
1439 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1440 result, &network_info,
1441 event_info->cb, event_info->user_data);
1442 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1443 const char *device = NULL;
1444 const char *address = NULL;
1445 bluetooth_network_device_info_t network_info;
1447 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1449 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1451 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1454 _bt_print_device_address_t(&network_info.device_address);
1456 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1457 result, &network_info,
1458 event_info->cb, event_info->user_data);
1462 void __bt_avrcp_event_filter(GDBusConnection *connection,
1463 const gchar *sender_name,
1464 const gchar *object_path,
1465 const gchar *interface_name,
1466 const gchar *signal_name,
1467 GVariant *parameters,
1470 bt_event_info_t *event_info;
1471 int result = BLUETOOTH_ERROR_NONE;
1472 event_info = (bt_event_info_t *)user_data;
1473 ret_if(event_info == NULL);
1475 if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1477 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1480 ret_if(signal_name == NULL);
1482 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1483 char *address = NULL;
1485 g_variant_get(parameters, "(i&s)", &result, &address);
1487 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1489 event_info->cb, event_info->user_data);
1490 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1491 char *address = NULL;
1493 g_variant_get(parameters, "(i&s)", &result, &address);
1495 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1497 event_info->cb, event_info->user_data);
1498 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1499 unsigned int status;
1501 g_variant_get(parameters, "(u)", &status);
1502 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1504 event_info->cb, event_info->user_data);
1505 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1506 unsigned int status;
1508 g_variant_get(parameters, "(u)", &status);
1509 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1511 event_info->cb, event_info->user_data);
1512 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1513 unsigned int status;
1515 g_variant_get(parameters, "(u)", &status);
1516 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1518 event_info->cb, event_info->user_data);
1519 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1520 unsigned int status;
1522 g_variant_get(parameters, "(u)", &status);
1523 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1525 event_info->cb, event_info->user_data);
1529 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1530 const gchar *sender_name,
1531 const gchar *object_path,
1532 const gchar *interface_name,
1533 const gchar *signal_name,
1534 GVariant *parameters,
1537 bt_event_info_t *event_info;
1538 int result = BLUETOOTH_ERROR_NONE;
1539 event_info = (bt_event_info_t *)user_data;
1540 ret_if(event_info == NULL);
1542 if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1544 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1547 ret_if(signal_name == NULL);
1549 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1550 char *address = NULL;
1552 g_variant_get(parameters, "(i&s)", &result, &address);
1554 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1556 event_info->cb, event_info->user_data);
1557 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1558 char *address = NULL;
1560 g_variant_get(parameters, "(i&s)", &result, &address);
1562 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1564 event_info->cb, event_info->user_data);
1565 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1566 unsigned int status;
1568 g_variant_get(parameters, "(u)", &status);
1569 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1571 event_info->cb, event_info->user_data);
1572 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1573 unsigned int status;
1575 g_variant_get(parameters, "(u)", &status);
1576 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1578 event_info->cb, event_info->user_data);
1579 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1580 unsigned int status;
1582 g_variant_get(parameters, "(u)", &status);
1583 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1585 event_info->cb, event_info->user_data);
1586 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1587 unsigned int status;
1589 g_variant_get(parameters, "(u)", &status);
1590 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1592 event_info->cb, event_info->user_data);
1593 } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1594 unsigned int status;
1596 g_variant_get(parameters, "(u)", &status);
1597 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1599 event_info->cb, event_info->user_data);
1600 } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1601 unsigned int status;
1603 g_variant_get(parameters, "(u)", &status);
1604 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1606 event_info->cb, event_info->user_data);
1607 } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1608 media_metadata_attributes_t metadata;
1613 unsigned int total_tracks;
1614 unsigned int number;
1615 unsigned int duration;
1617 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1618 &artist, &album, &genre,
1619 &total_tracks, &number,
1621 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1623 metadata.title = title;
1624 metadata.artist = artist;
1625 metadata.album = album;
1626 metadata.genre = genre;
1627 metadata.total_tracks = total_tracks;
1628 metadata.number = number;
1629 metadata.duration = (int64_t)duration;
1631 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1633 event_info->cb, event_info->user_data);
1637 void __bt_opp_client_event_filter(GDBusConnection *connection,
1638 const gchar *sender_name,
1639 const gchar *object_path,
1640 const gchar *interface_name,
1641 const gchar *signal_name,
1642 GVariant *parameters,
1645 bt_event_info_t *event_info;
1646 int result = BLUETOOTH_ERROR_NONE;
1647 event_info = (bt_event_info_t *)user_data;
1648 ret_if(event_info == NULL);
1650 if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1652 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1655 ret_if(signal_name == NULL);
1657 if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1658 const char *address = NULL;
1660 bluetooth_device_address_t dev_address = { {0} };
1662 g_variant_get(parameters, "(i&si)", &result,
1663 &address, &request_id);
1665 if (__bt_is_request_id_exist(request_id) == FALSE) {
1666 BT_ERR("Different request id!");
1670 _bt_convert_addr_string_to_type(dev_address.addr,
1673 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1674 result, &dev_address,
1675 event_info->cb, event_info->user_data);
1677 if (result != BLUETOOTH_ERROR_NONE)
1678 __bt_remove_push_request_id(request_id);
1680 } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1681 const char *address = NULL;
1683 bluetooth_device_address_t dev_address = { {0} };
1685 g_variant_get(parameters, "(i&si)", &result, &address,
1688 if (__bt_is_request_id_exist(request_id) == FALSE) {
1689 BT_ERR("Different request id!");
1693 _bt_convert_addr_string_to_type(dev_address.addr,
1696 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1697 result, &dev_address,
1698 event_info->cb, event_info->user_data);
1700 __bt_remove_push_request_id(request_id);
1701 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1702 const char *file_name = NULL;
1703 const char *device_addr = NULL;
1706 bt_opc_transfer_info_t transfer_info;
1708 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
1709 &size, &request_id);
1711 if (__bt_is_request_id_exist(request_id) == FALSE) {
1712 BT_ERR("Different request id!");
1716 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1718 transfer_info.filename = g_strdup(file_name);
1719 transfer_info.device_addr = g_strdup(device_addr);
1720 transfer_info.size = size;
1722 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1723 result, &transfer_info,
1724 event_info->cb, event_info->user_data);
1726 g_free(transfer_info.device_addr);
1727 g_free(transfer_info.filename);
1728 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1729 const char *file_name = NULL;
1733 bt_opc_transfer_info_t transfer_info;
1735 g_variant_get(parameters, "(i&stii)", &result,
1736 &file_name, &size, &progress, &request_id);
1738 if (__bt_is_request_id_exist(request_id) == FALSE) {
1739 BT_ERR("Different request id!");
1743 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1745 transfer_info.filename = g_strdup(file_name);
1746 transfer_info.size = size;
1747 transfer_info.percentage = progress;
1749 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1750 result, &transfer_info,
1751 event_info->cb, event_info->user_data);
1753 g_free(transfer_info.filename);
1754 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1755 const char *file_name = NULL;
1756 const char *device_addr = NULL;
1759 bt_opc_transfer_info_t transfer_info;
1761 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
1762 &file_name, &size, &request_id);
1764 if (__bt_is_request_id_exist(request_id) == FALSE) {
1765 BT_ERR("Different request id!");
1769 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1771 transfer_info.device_addr = g_strdup(device_addr);
1772 transfer_info.filename = g_strdup(file_name);
1773 transfer_info.size = size;
1775 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1776 result, &transfer_info,
1777 event_info->cb, event_info->user_data);
1779 g_free(transfer_info.device_addr);
1780 g_free(transfer_info.filename);
1784 void __bt_opp_server_event_filter(GDBusConnection *connection,
1785 const gchar *sender_name,
1786 const gchar *object_path,
1787 const gchar *interface_name,
1788 const gchar *signal_name,
1789 GVariant *parameters,
1792 bt_event_info_t *event_info;
1793 int result = BLUETOOTH_ERROR_NONE;
1794 event_info = (bt_event_info_t *)user_data;
1795 ret_if(event_info == NULL);
1797 if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1799 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1802 ret_if(signal_name == NULL);
1804 if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1805 /* Native only event */
1806 const char *file_name = NULL;
1807 const char *address = NULL;
1808 const char *device_name = NULL;
1810 bt_obex_server_authorize_into_t auth_info;
1812 g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
1813 &address, &device_name);
1815 /* OSP server: Don't get this event */
1816 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1818 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1820 auth_info.filename = g_strdup(file_name);
1821 auth_info.length = size;
1822 auth_info.address = g_strdup(address);
1823 auth_info.name = g_strdup(device_name);
1824 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1826 event_info->cb, event_info->user_data);
1828 g_free(auth_info.filename);
1829 g_free(auth_info.address);
1830 g_free(auth_info.name);
1831 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1832 /* OSP only event */
1833 const char *address = NULL;
1834 const char *name = NULL;
1835 bluetooth_device_address_t dev_address = { {0} };
1837 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1839 /* Native server: Don't get this event */
1840 ret_if(obex_server_id == BT_NATIVE_SERVER);
1842 _bt_convert_addr_string_to_type(dev_address.addr,
1845 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1846 result, &dev_address,
1847 event_info->cb, event_info->user_data);
1848 } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1849 bt_obex_server_connection_info_t conn_info = {0, };
1850 char *address = NULL;
1852 int transfer_id = -1;
1853 g_variant_get(parameters, "(i&s&si)", &result,
1854 &address, &name, &transfer_id);
1856 conn_info.address = g_strdup(address);
1857 conn_info.device_name = g_strdup(name);
1858 conn_info.transfer_id = transfer_id;
1860 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1861 result, &conn_info, event_info->cb,
1862 event_info->user_data);
1864 g_free(conn_info.address);
1865 g_free(conn_info.device_name);
1866 } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1867 bt_obex_server_transfer_info_t transfer_info = {0, };
1868 char *address = NULL;
1869 int transfer_id = -1;
1870 g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
1871 DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
1873 transfer_info.address = g_strdup(address);
1874 transfer_info.transfer_id = transfer_id;
1876 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1877 result, &transfer_info, event_info->cb,
1878 event_info->user_data);
1879 g_free(transfer_info.address);
1880 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1881 const char *device_name = NULL;
1882 const char *file_name = NULL;
1883 const char *type = NULL;
1884 const char *address = NULL;
1885 GVariantIter *iter = NULL;
1888 int transfer_id = 0;
1889 int server_type = 0; /* bt_server_type_t */
1891 bt_obex_server_transfer_info_t transfer_info;
1893 g_variant_get(parameters, "(i&s&s&s&stii(ay))", &result, &device_name,
1894 &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
1896 /* Other server's event */
1897 ret_if(obex_server_id != server_type &&
1898 server_type != BT_FTP_SERVER);
1900 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1902 transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
1904 for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
1905 transfer_info.contact_auth_info[i] = byte;
1907 transfer_info.device_name = g_strdup(device_name);
1908 transfer_info.filename = g_strdup(file_name);
1909 transfer_info.type = g_strdup(type);
1910 transfer_info.address = g_strdup(address);
1911 transfer_info.file_size = size;
1912 transfer_info.transfer_id = transfer_id;
1913 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1914 FTP_SERVER : OPP_SERVER;
1916 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1917 result, &transfer_info,
1918 event_info->cb, event_info->user_data);
1920 g_free(transfer_info.filename);
1921 g_free(transfer_info.type);
1922 g_free(transfer_info.device_name);
1923 g_free(transfer_info.address);
1924 g_free(transfer_info.contact_auth_info);
1925 g_variant_iter_free(iter);
1926 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1927 const char *file_name = NULL;
1928 const char *type = NULL;
1929 const char *device_name = NULL;
1930 const char *address = NULL;
1931 int transfer_id = 0;
1933 int server_type = 0; /* bt_server_type_t */
1935 bt_obex_server_transfer_info_t transfer_info;
1937 g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
1938 &type, &device_name, &address, &size, &transfer_id,
1939 &progress, &server_type);
1941 /* Other server's event */
1942 ret_if(obex_server_id != server_type &&
1943 server_type != BT_FTP_SERVER);
1945 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1947 transfer_info.filename = g_strdup(file_name);
1948 transfer_info.type = g_strdup(type);
1949 transfer_info.device_name = g_strdup(device_name);
1950 transfer_info.address = g_strdup(address);
1951 transfer_info.file_size = size;
1952 transfer_info.transfer_id = transfer_id;
1953 transfer_info.percentage = progress;
1954 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1955 FTP_SERVER : OPP_SERVER;
1957 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1958 result, &transfer_info,
1959 event_info->cb, event_info->user_data);
1961 g_free(transfer_info.filename);
1962 g_free(transfer_info.device_name);
1963 g_free(transfer_info.address);
1964 g_free(transfer_info.type);
1965 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1966 const char *file_name = NULL;
1967 const char *device_name = NULL;
1968 const char *address = NULL;
1969 const char *type = NULL;
1970 const char *file_path;
1971 int transfer_id = 0;
1972 int server_type = 0; /* bt_server_type_t */
1974 bt_obex_server_transfer_info_t transfer_info;
1976 g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
1977 &type, &device_name, &file_path, &address, &size,
1978 &transfer_id, &server_type);
1980 /* Other server's event */
1981 ret_if(obex_server_id != server_type &&
1982 server_type != BT_FTP_SERVER);
1984 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1986 transfer_info.filename = g_strdup(file_name);
1987 transfer_info.type = g_strdup(type);
1988 transfer_info.device_name = g_strdup(device_name);
1989 transfer_info.file_path = g_strdup(file_path);
1990 transfer_info.address = g_strdup(address);
1991 transfer_info.file_size = size;
1992 transfer_info.transfer_id = transfer_id;
1993 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1994 FTP_SERVER : OPP_SERVER;
1996 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1997 result, &transfer_info,
1998 event_info->cb, event_info->user_data);
2000 g_free(transfer_info.filename);
2001 g_free(transfer_info.type);
2002 g_free(transfer_info.device_name);
2003 g_free(transfer_info.address);
2004 g_free(transfer_info.file_path);
2008 void __bt_pbap_client_event_filter(GDBusConnection *connection,
2009 const gchar *sender_name,
2010 const gchar *object_path,
2011 const gchar *interface_name,
2012 const gchar *signal_name,
2013 GVariant *parameters,
2016 bt_event_info_t *event_info;
2017 int result = BLUETOOTH_ERROR_NONE;
2018 event_info = (bt_event_info_t *)user_data;
2020 ret_if(event_info == NULL);
2022 if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
2025 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2028 ret_if(signal_name == NULL);
2030 BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2032 if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2033 bt_pbap_connected_t connected = { { { 0 }, }, };
2034 char *address = NULL;
2036 g_variant_get(parameters, "(i&s)", &result, &address);
2037 BT_DBG("address: %s", address);
2039 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2042 connected.connected = 1;
2044 connected.connected = 0;
2046 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2048 event_info->cb, event_info->user_data);
2049 } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2050 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2051 char *address = NULL;
2053 g_variant_get(parameters, "(i&s)", &result, &address);
2054 BT_DBG("address: %s", address);
2056 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2058 disconnected.connected = 0;
2060 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
2061 result, &disconnected,
2062 event_info->cb, event_info->user_data);
2063 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2064 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2065 char *address = NULL;
2068 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2070 BT_DBG("address: %s, size: %d", address, size);
2072 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2074 pb_size.size = size;
2076 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2078 event_info->cb, event_info->user_data);
2079 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2080 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2081 char *address = NULL;
2082 char *vcf_file = NULL;
2085 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2087 BT_DBG("address: %s, vcf_file: %s, success: %d",
2088 address, vcf_file, success);
2090 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2092 pb_pull.vcf_file = vcf_file;
2093 pb_pull.success = success;
2094 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2096 event_info->cb, event_info->user_data);
2097 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2098 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2099 char *address = NULL;
2101 gchar **list = NULL;
2102 GVariant *string_var;
2106 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2108 list = (gchar **)g_variant_get_strv(string_var, &count);
2112 for (i = 0; i < count; i++)
2113 BT_DBG("%s", list[i]);
2115 BT_DBG("address: %s, result: %d, count: %d, success: %d",
2116 address, result, count, success);
2118 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2120 vc_list.vcards = list;
2121 vc_list.length = count;
2122 vc_list.success = success;
2123 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2125 event_info->cb, event_info->user_data);
2127 g_variant_unref(string_var);
2129 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2130 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2131 char *address = NULL;
2132 char *vcf_file = NULL;
2135 g_variant_get(parameters, "(i&s&si)",
2136 &result, &address, &vcf_file, &success);
2138 BT_DBG("address: %s, vcf_file: %s, success: %d",
2139 address, vcf_file, success);
2141 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2142 vc_pull.vcf_file = vcf_file;
2143 vc_pull.success = success;
2144 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2146 event_info->cb, event_info->user_data);
2147 } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2148 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2149 char *address = NULL;
2151 gchar **list = NULL;
2152 GVariant *string_var;
2156 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2158 list = (gchar **)g_variant_get_strv(string_var, &count);
2160 for (i = 0; i < count; i++)
2161 BT_DBG("%s", list[i]);
2163 BT_DBG("address: %s success: %d", address, success);
2165 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2166 vc_list.vcards = list;
2167 vc_list.length = count;
2168 vc_list.success = success;
2169 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2171 event_info->cb, event_info->user_data);
2173 g_variant_unref(string_var);
2178 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2179 const gchar *sender_name,
2180 const gchar *object_path,
2181 const gchar *interface_name,
2182 const gchar *signal_name,
2183 GVariant *parameters,
2186 bt_event_info_t *event_info;
2187 int result = BLUETOOTH_ERROR_NONE;
2188 event_info = (bt_event_info_t *)user_data;
2189 ret_if(event_info == NULL);
2191 if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2193 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2196 ret_if(signal_name == NULL);
2198 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2199 const char *address = NULL;
2200 const char *uuid = NULL;
2202 bluetooth_rfcomm_connection_t conn_info;
2204 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2207 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2208 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2209 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2210 conn_info.socket_fd = socket_fd;
2211 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2214 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2216 event_info->cb, event_info->user_data);
2217 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2218 const char *address = NULL;
2219 const char *uuid = NULL;
2221 bluetooth_rfcomm_disconnection_t disconn_info;
2223 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2226 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2227 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2228 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2229 disconn_info.socket_fd = socket_fd;
2230 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2233 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2234 result, &disconn_info,
2235 event_info->cb, event_info->user_data);
2236 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2240 bluetooth_rfcomm_received_data_t data_r;
2243 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2246 buffer_len = g_variant_get_size(byte_var);
2247 buffer = (char *) g_variant_get_data(byte_var);
2249 data_r.socket_fd = socket_fd;
2250 data_r.buffer_size = buffer_len;
2251 data_r.buffer = buffer;
2253 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2255 event_info->cb, event_info->user_data);
2256 g_variant_unref(byte_var);
2260 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2261 const gchar *sender_name,
2262 const gchar *object_path,
2263 const gchar *interface_name,
2264 const gchar *signal_name,
2265 GVariant *parameters,
2268 bt_event_info_t *event_info;
2269 int result = BLUETOOTH_ERROR_NONE;
2270 event_info = (bt_event_info_t *)user_data;
2271 ret_if(event_info == NULL);
2273 if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2275 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2278 ret_if(signal_name == NULL);
2280 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2281 const char *address = NULL;
2282 const char *uuid = NULL;
2284 bluetooth_rfcomm_connection_t conn_info;
2286 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2289 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2290 conn_info.device_role = RFCOMM_ROLE_SERVER;
2291 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2292 conn_info.socket_fd = socket_fd;
2293 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2296 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2298 event_info->cb, event_info->user_data);
2299 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2300 const char *address = NULL;
2301 const char *uuid = NULL;
2303 bluetooth_rfcomm_disconnection_t disconn_info;
2305 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2308 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2309 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2310 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2311 disconn_info.socket_fd = socket_fd;
2312 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2315 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2316 result, &disconn_info,
2317 event_info->cb, event_info->user_data);
2318 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2319 /* OSP only event */
2320 bluetooth_rfcomm_connection_request_t req_ind;
2321 char *address = NULL;
2327 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2328 &uuid, &name, &path, &socket_fd);
2330 if (_check_uuid_path(path, uuid) == FALSE)
2333 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2334 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2337 req_ind.socket_fd = socket_fd;
2339 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2341 event_info->cb, event_info->user_data);
2342 } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2343 /* OSP only event */
2346 g_variant_get(parameters, "(in)", &result, &socket_fd);
2348 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2350 _bt_remove_server(socket_fd);
2351 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2352 char *buffer = NULL;
2355 bluetooth_rfcomm_received_data_t data_r;
2358 g_variant_get(parameters, "(in@ay)", &result,
2359 &socket_fd, &byte_var);
2361 buffer_len = g_variant_get_size(byte_var);
2362 buffer = (char *) g_variant_get_data(byte_var);
2364 data_r.socket_fd = socket_fd;
2365 data_r.buffer_size = buffer_len;
2366 data_r.buffer = buffer;
2368 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2370 event_info->cb, event_info->user_data);
2371 g_variant_unref(byte_var);
2375 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2376 const gchar *sender_name,
2377 const gchar *object_path,
2378 const gchar *interface_name,
2379 const gchar *signal_name,
2380 GVariant *parameters,
2385 bt_event_info_t *event_info;
2386 int result = BLUETOOTH_ERROR_NONE;
2387 event_info = (bt_event_info_t *)user_data;
2388 ret_if(event_info == NULL);
2391 if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2393 if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2396 ret_if(signal_name == NULL);
2398 BT_DBG("%s", signal_name);
2399 if (strcasecmp(signal_name, "Connected") == 0) {
2400 char *address = NULL;
2402 g_variant_get(parameters, "(s)", &address);
2403 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2405 event_info->cb, event_info->user_data);
2406 } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2407 char *address = NULL;
2409 g_variant_get(parameters, "(s)", &address);
2410 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2412 event_info->cb, event_info->user_data);
2413 } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2414 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2416 event_info->cb, event_info->user_data);
2417 } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2418 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2420 event_info->cb, event_info->user_data);
2421 } else if (strcasecmp(signal_name, "Ring") == 0) {
2422 char *phoneno = NULL;
2424 g_variant_get(parameters, "(&s)", &phoneno);
2426 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2428 event_info->cb, event_info->user_data);
2429 } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2430 char *phoneno = NULL;
2432 g_variant_get(parameters, "(&s)", &phoneno);
2434 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2436 event_info->cb, event_info->user_data);
2437 } else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2438 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2440 event_info->cb, event_info->user_data);
2441 } else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2442 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2444 event_info->cb, event_info->user_data);
2445 } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2446 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2448 event_info->cb, event_info->user_data);
2449 } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2450 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2452 event_info->cb, event_info->user_data);
2453 } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2454 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2456 event_info->cb, event_info->user_data);
2457 } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2458 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2460 event_info->cb, event_info->user_data);
2461 } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2462 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2464 event_info->cb, event_info->user_data);
2465 } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2466 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2468 event_info->cb, event_info->user_data);
2469 } else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2470 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2472 event_info->cb, event_info->user_data);
2473 } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2474 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2476 event_info->cb, event_info->user_data);
2477 } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2478 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2480 event_info->cb, event_info->user_data);
2481 } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2483 GVariant *var_data = NULL;
2484 char *number = NULL;
2485 int idx, dir, status, mpart;
2486 bt_hf_call_list_s *handle = NULL;
2488 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2490 BT_DBG("call count : %d", call_count);
2493 GVariantIter *iter = NULL;
2494 __bt_call_list_create(&handle);
2496 g_variant_get(var_data, "a(siiii)", &iter);
2497 while (g_variant_iter_loop(iter, "(siiii)", &number,
2498 &dir, &status, &mpart, &idx)) {
2499 BT_DBG("call number:%s, dir:%d, status : %d",
2500 number, dir, status);
2501 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2502 __bt_call_list_add(handle, number, dir,
2503 status, mpart, idx);
2505 g_variant_iter_free(iter);
2506 g_variant_unref(var_data);
2509 if (handle && (call_count == g_list_length(handle->list))) {
2510 handle->count = call_count;
2511 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2513 event_info->cb, event_info->user_data);
2515 BT_ERR(" Mismatch in call count : %d", call_count);
2518 __bt_call_list_destroy(handle);
2519 } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2521 g_variant_get(parameters, "(i)", &status);
2522 BT_DBG("status = [%d]\n", status);
2524 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2526 event_info->cb, event_info->user_data);
2528 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2530 event_info->cb, event_info->user_data);
2531 } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2533 g_variant_get(parameters, "(i)", &value);
2534 BT_DBG("Value = [%d]\n", value);
2535 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2537 event_info->cb, event_info->user_data);
2538 } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2541 bluetooth_vendor_dep_at_cmd_t cmd;
2542 g_variant_get(parameters, "(i&s)", &value, &msg);
2543 BT_DBG("Value = [%d], message = %s\n", value, msg);
2546 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2548 event_info->cb, event_info->user_data);
2549 } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
2552 bluetooth_hf_ciev_device_event_t dev_event;
2554 g_variant_get(parameters, "(&sv)", &property, &value);
2555 dev_event.value = g_variant_get_uint16(value);
2557 BT_DBG("Property: %s , value: %d", property, dev_event.value);
2558 g_variant_unref(value);
2560 if (strcasecmp(property, "BatteryCharge") == 0) {
2561 dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
2562 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2564 event_info->cb, event_info->user_data);
2565 } else if (strcasecmp(property, "SignalStrength") == 0) {
2566 dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
2567 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2569 event_info->cb, event_info->user_data);
2570 } else if (strcasecmp(property, "RegistrationStatus") == 0) {
2571 dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
2572 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2574 event_info->cb, event_info->user_data);
2580 static void __bt_remove_all_events(void)
2582 bt_event_info_t *info;
2584 while ((info = g_slist_nth_data(event_list, 0)) != NULL)
2585 _bt_unregister_event(info->event_type);
2588 g_slist_free(event_list);
2593 static gboolean __bt_event_is_registered(int event_type)
2596 bt_event_info_t *info;
2598 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2603 if (info->event_type == event_type)
2610 bt_event_info_t *_bt_event_get_cb_data(int event_type)
2613 bt_event_info_t *info;
2615 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2620 if (info->event_type == event_type)
2627 void _bt_add_server(int server_fd)
2629 bt_server_info_t *info;
2631 info = g_new0(bt_server_info_t, 1);
2632 info->server_fd = server_fd;
2634 server_list = g_slist_append(server_list, info);
2637 void _bt_remove_server(int server_fd)
2640 bt_server_info_t *info;
2642 for (l = server_list; l != NULL; l = g_slist_next(l)) {
2647 if (info->server_fd == server_fd)
2648 server_list = g_slist_remove(server_list, (void *)info);
2654 void _bt_set_obex_server_id(int server_type)
2656 obex_server_id = server_type;
2659 int _bt_get_obex_server_id(void)
2661 return obex_server_id;
2664 int _bt_init_event_handler(void)
2666 if (is_initialized == TRUE) {
2667 BT_ERR("Connection already exist");
2668 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2671 __bt_remove_all_events();
2673 is_initialized = TRUE;
2675 return BLUETOOTH_ERROR_NONE;
2678 int _bt_deinit_event_handler(void)
2680 if (is_initialized == FALSE) {
2681 BT_ERR("Connection dose not exist");
2682 return BLUETOOTH_ERROR_INTERNAL;
2685 __bt_remove_all_events();
2687 if (disable_timer_id > 0) {
2688 g_source_remove(disable_timer_id);
2689 disable_timer_id = 0;
2692 is_initialized = FALSE;
2694 return BLUETOOTH_ERROR_NONE;
2697 static void __bt_event_data_free(void *data)
2699 bt_event_info_t *cb_data = data;
2701 ret_if(cb_data == NULL);
2706 int _bt_register_event(int event_type, void *event_cb, void *user_data)
2708 GDBusConnection *connection_type;
2709 GDBusSignalCallback event_func;
2710 bt_event_info_t *cb_data;
2712 const char *interface = BT_EVENT_SERVICE;
2714 if (is_initialized == FALSE)
2715 _bt_init_event_handler();
2717 if (__bt_event_is_registered(event_type) == TRUE) {
2718 BT_ERR("The event is already registed");
2719 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2722 switch (event_type) {
2723 case BT_ADAPTER_EVENT:
2724 event_func = __bt_adapter_event_filter;
2725 path = BT_ADAPTER_PATH;
2727 case BT_LE_ADAPTER_EVENT:
2728 event_func = __bt_adapter_le_event_filter;
2729 path = BT_LE_ADAPTER_PATH;
2731 case BT_DEVICE_EVENT:
2732 event_func = __bt_device_event_filter;
2733 path = BT_DEVICE_PATH;
2736 event_func = __bt_hid_event_filter;
2739 case BT_HEADSET_EVENT:
2740 event_func = __bt_headset_event_filter;
2741 path = BT_HEADSET_PATH;
2743 case BT_NETWORK_EVENT:
2744 event_func = __bt_network_event_filter;
2745 path = BT_NETWORK_PATH;
2747 case BT_AVRCP_EVENT:
2748 event_func = __bt_avrcp_event_filter;
2749 path = BT_AVRCP_PATH;
2751 case BT_AVRCP_CONTROL_EVENT:
2752 event_func = __bt_avrcp_control_event_filter;
2753 path = BT_AVRCP_CONTROL_PATH;
2755 case BT_OPP_CLIENT_EVENT:
2756 event_func = __bt_opp_client_event_filter;
2757 path = BT_OPP_CLIENT_PATH;
2759 case BT_OPP_SERVER_EVENT:
2760 event_func = __bt_opp_server_event_filter;
2761 path = BT_OPP_SERVER_PATH;
2763 case BT_PBAP_CLIENT_EVENT:
2764 event_func = __bt_pbap_client_event_filter;
2765 path = BT_PBAP_CLIENT_PATH;
2767 case BT_RFCOMM_CLIENT_EVENT:
2768 event_func = __bt_rfcomm_client_event_filter;
2769 path = BT_RFCOMM_CLIENT_PATH;
2771 case BT_RFCOMM_SERVER_EVENT:
2772 event_func = __bt_rfcomm_server_event_filter;
2773 path = BT_RFCOMM_SERVER_PATH;
2775 case BT_HF_AGENT_EVENT:
2776 BT_DBG("BT_HF_AGENT_EVENT\n");
2777 event_func = __bt_hf_agent_event_filter;
2778 path = BT_HF_AGENT_PATH;
2779 interface = BT_HF_SERVICE_INTERFACE;
2781 case BT_A2DP_SOURCE_EVENT:
2782 BT_DBG("BT_A2DP_SOURCE_EVENT");
2783 event_func = __bt_a2dp_source_event_filter;
2784 path = BT_A2DP_SOURCE_PATH;
2786 case BT_HID_DEVICE_EVENT:
2787 BT_DBG("BT_HID_DEVICE_EVENT");
2788 event_func = __bt_hid_device_event_filter;
2789 path = BT_HID_DEVICE_PATH;
2791 #ifdef GATT_NO_RELAY
2792 case BT_GATT_BLUEZ_EVENT:
2793 BT_DBG("BT_GATT_BLUEZ_EVENT");
2794 event_func = __bt_device_event_filter;
2795 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2800 BT_ERR("Unknown event");
2801 return BLUETOOTH_ERROR_INTERNAL;
2804 connection_type = _bt_gdbus_get_system_gconn();
2805 if (connection_type == NULL)
2806 return BLUETOOTH_ERROR_INTERNAL;
2808 cb_data = g_new0(bt_event_info_t, 1);
2810 cb_data->event_type = event_type;
2811 cb_data->cb = event_cb;
2812 cb_data->user_data = user_data;
2814 cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2815 NULL, interface, NULL, path, NULL, 0,
2816 event_func, cb_data, NULL);
2818 event_list = g_slist_append(event_list, cb_data);
2820 return BLUETOOTH_ERROR_NONE;
2823 int _bt_unregister_event(int event_type)
2825 GDBusConnection *connection_type;
2826 bt_event_info_t *cb_data;
2828 if (is_initialized == FALSE) {
2829 BT_ERR("Event is not registered");
2830 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2833 if (__bt_event_is_registered(event_type) == FALSE) {
2834 BT_ERR("Not registered event");
2835 return BLUETOOTH_ERROR_INTERNAL;
2838 cb_data = _bt_event_get_cb_data(event_type);
2840 if (cb_data == NULL) {
2841 BT_ERR("No matched event data");
2842 return BLUETOOTH_ERROR_INTERNAL;
2845 connection_type = _bt_gdbus_get_system_gconn();
2847 event_list = g_slist_remove(event_list, (void *)cb_data);
2849 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2851 g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2853 __bt_event_data_free((void *)cb_data);
2855 return BLUETOOTH_ERROR_NONE;
2858 static void __bt_name_owner_changed(GDBusConnection *connection,
2859 const gchar *sender_name,
2860 const gchar *object_path,
2861 const gchar *interface_name,
2862 const gchar *signal_name,
2863 GVariant *parameters,
2866 const char *name = NULL;
2867 const char *old_owner = NULL;
2868 const char *new_owner = NULL;
2869 bt_event_info_t *event_info;
2871 g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2873 if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2874 (new_owner != NULL && *new_owner == '\0')) {
2875 BT_DBG("bt-service is terminated");
2876 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2877 if (event_info == NULL)
2880 if (disable_timer_id > 0)
2881 g_source_remove(disable_timer_id);
2883 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2884 (GSourceFunc)__bt_reliable_disable_cb,
2889 void _bt_register_name_owner_changed(void)
2891 GDBusConnection *connection_type;
2893 connection_type = _bt_gdbus_get_system_gconn();
2894 if (connection_type == NULL) {
2895 BT_ERR("Unable to get the bus");
2898 owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2899 NULL, DBUS_INTERFACE_DBUS,
2900 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2901 __bt_name_owner_changed, NULL, NULL);
2904 void _bt_unregister_name_owner_changed(void)
2906 GDBusConnection *connection_type;
2908 connection_type = _bt_gdbus_get_system_gconn();
2909 if (connection_type != NULL && owner_sig_id != -1) {
2910 g_dbus_connection_signal_unsubscribe(connection_type,
2916 static void __bt_manager_event_filter(GDBusConnection *connection,
2917 const gchar *sender_name,
2918 const gchar *object_path,
2919 const gchar *interface_name,
2920 const gchar *signal_name,
2921 GVariant *parameters,
2925 GVariantIter *interface_iter = NULL;
2926 char *interface_str = NULL;
2927 bt_gatt_service_change_t change;
2928 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2929 char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
2930 bt_user_info_t *user_info = NULL;
2932 if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
2933 g_variant_get(parameters, "(&s)", &path);
2935 _bt_convert_device_path_to_address(path, address);
2936 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
2937 _bt_convert_addr_string_to_secure_string(secure_address, address);
2939 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
2941 BT_INFO("GATT Service [%s] added, but no watcher for %s",
2942 path, secure_address);
2945 BT_INFO("GATT Service [%s] added : %s",
2946 path, secure_address);
2948 change.svc_path = g_strdup(path);
2949 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
2951 user_info = _bt_get_user_data(BT_COMMON);
2952 if (user_info != NULL) {
2953 _bt_common_event_cb(
2954 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
2955 BLUETOOTH_ERROR_NONE, &change,
2956 user_info->cb, user_info->user_data);
2959 g_free(change.svc_path);
2960 } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
2961 g_variant_get(parameters, "(&oas)",
2962 &path, &interface_iter);
2965 BT_ERR("Invalid adapter path");
2969 _bt_convert_device_path_to_address(path, address);
2970 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
2971 _bt_convert_addr_string_to_secure_string(secure_address, address);
2973 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
2975 BT_INFO("GATT Service [%s] removed, but no watcher for %s",
2976 path, secure_address);
2980 while (g_variant_iter_loop(interface_iter, "s", &interface_str)) {
2981 if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) == 0) {
2982 change.svc_path = g_strdup(path);
2983 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
2985 BT_INFO("GATT Service [%s] is removed : %s",
2986 path, secure_address);
2988 user_info = _bt_get_user_data(BT_COMMON);
2989 if (user_info != NULL) {
2990 _bt_common_event_cb(
2991 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
2992 BLUETOOTH_ERROR_NONE, &change,
2993 user_info->cb, user_info->user_data);
2996 g_free(change.svc_path);
3000 g_variant_iter_free(interface_iter);
3004 int _bt_register_manager_subscribe_signal(gboolean subscribe)
3006 GDBusConnection *g_conn;
3007 static int service_added_id = -1;
3008 static int interface_removed_id = -1;
3010 g_conn = _bt_gdbus_get_system_gconn();
3012 return BLUETOOTH_ERROR_INTERNAL;
3014 if (subscribe == TRUE) {
3015 if (service_added_id == -1) {
3016 service_added_id = g_dbus_connection_signal_subscribe(g_conn,
3017 NULL, GATT_SERV_INTERFACE,
3018 "GattServiceAdded", NULL, NULL, 0,
3019 __bt_manager_event_filter,
3022 if (interface_removed_id == -1) {
3023 interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
3024 NULL, BT_MANAGER_INTERFACE,
3025 "InterfacesRemoved", NULL, NULL, 0,
3026 __bt_manager_event_filter,
3030 if (service_added_id != -1) {
3031 g_dbus_connection_signal_unsubscribe(g_conn,
3033 service_added_id = -1;
3035 if (interface_removed_id != -1) {
3036 g_dbus_connection_signal_unsubscribe(g_conn,
3037 interface_removed_id);
3038 interface_removed_id = -1;
3042 return BLUETOOTH_ERROR_NONE;