2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <dbus/dbus.h>
24 #include "bluetooth-api.h"
25 #include "bluetooth-audio-api.h"
26 #include "bt-internal-types.h"
27 #include "bluetooth-media-control.h"
29 #include "bt-common.h"
30 #include "bt-event-handler.h"
31 #include "bt-request-sender.h"
33 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
43 static int obex_server_id;
44 static guint disable_timer_id;
45 static gboolean is_initialized;
46 static GSList *sending_list = NULL;
47 static GSList *server_list = NULL;
48 static GSList *event_list = NULL;
49 static int owner_sig_id = -1;
50 static gboolean is_adapter_enabled = TRUE;
52 void _bt_add_push_request_id(int request_id)
54 bt_sending_info_t *info;
56 info = g_new0(bt_sending_info_t, 1);
57 info->request_id = request_id;
59 sending_list = g_slist_append(sending_list, info);
62 static gboolean __bt_is_request_id_exist(int request_id)
65 bt_sending_info_t *info;
67 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
72 if (info->request_id == request_id)
79 static void __bt_remove_push_request_id(int request_id)
82 bt_sending_info_t *info;
84 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
89 BT_DBG("info->request_id = %d\n", info->request_id);
90 BT_DBG("request_id = %d\n", request_id);
91 if (info->request_id == request_id) {
92 sending_list = g_slist_remove(sending_list, (void *)info);
99 static void __bt_remove_all_push_request_id(void)
102 bt_sending_info_t *info;
104 for (l = sending_list; l != NULL; l = g_slist_next(l)) {
109 g_slist_free(sending_list);
113 static void __bt_remove_all_server(void)
116 bt_server_info_t *info;
118 for (l = server_list; l != NULL; l = g_slist_next(l)) {
123 g_slist_free(server_list);
127 static gboolean __bt_is_server_exist(int server_fd)
130 bt_server_info_t *info;
132 for (l = server_list; l != NULL; l = g_slist_next(l)) {
137 retv_if(info->server_fd == server_fd, TRUE);
143 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
150 ret_if(dev_info == NULL);
151 ret_if(uuids == NULL);
152 ret_if(uuid_count <= 0);
154 dev_info->service_index = uuid_count;
156 for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
157 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
159 parts = g_strsplit(uuids[i], "-", -1);
161 if (parts == NULL || parts[0] == NULL) {
166 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
170 static int __bt_call_list_create(bt_hf_call_list_s **list)
172 bt_hf_call_list_s *handle;
175 BT_DBG("Already Initialized");
176 return BLUETOOTH_ERROR_NONE;
178 handle = g_malloc0(sizeof(bt_hf_call_list_s));
180 return BLUETOOTH_ERROR_NONE;
183 static int __bt_call_list_reset(bt_hf_call_list_s *list)
185 bt_hf_call_list_s *handle;
186 bt_hf_call_status_info_t *call_status;
189 BT_ERR("invalid parameter");
190 return BLUETOOTH_ERROR_INVALID_PARAM;
192 handle = (bt_hf_call_list_s *)list;
194 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(handle->list, 0);
195 if (call_status == NULL)
197 handle->list = g_list_remove(handle->list, call_status);
198 g_free(call_status->number);
201 return BLUETOOTH_ERROR_NONE;
204 static int __bt_call_list_destroy(bt_hf_call_list_s *list)
207 bt_hf_call_list_s *handle;
210 BT_ERR("invalid parameter");
211 return BLUETOOTH_ERROR_INVALID_PARAM;
213 handle = (bt_hf_call_list_s *)list;
214 result = __bt_call_list_reset(list);
218 static int __bt_call_list_add(bt_hf_call_list_s *list, char * number,
219 int dir, int status, int mpart, int idx)
221 bt_hf_call_list_s *handle;
222 bt_hf_call_status_info_t *call_status;
225 BT_ERR("invalid parameter");
226 return BLUETOOTH_ERROR_INVALID_PARAM;
228 handle = (bt_hf_call_list_s *)list;
229 call_status = g_malloc0(sizeof(bt_hf_call_status_info_t));
230 /* Fix : NULL_RETURNS */
231 retv_if(call_status == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
233 call_status->number = g_strdup(number);
234 call_status->direction = dir;
235 call_status->status = status;
236 call_status->mpart = mpart;
237 call_status->idx = idx;
238 handle->list = g_list_append(handle->list, (gpointer)call_status);
239 return BLUETOOTH_ERROR_NONE;
242 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
244 bluetooth_device_info_t *dev_info;
245 const char *address = NULL;
246 const char *name = NULL;
247 gchar **uuids = NULL;
248 unsigned int dev_class = 0;
250 gboolean paired = FALSE;
252 gboolean trust = FALSE;
254 int result = BLUETOOTH_ERROR_NONE;
255 GVariant *string_var;
257 int manufacturer_data_len = 0;
258 GVariant *manufacturer_var = NULL;
259 const char *manufacturer_data = NULL;
261 g_variant_get(parameters, "(isunsbub@asn@ay)", &result, &address,
262 &dev_class, &rssi, &name, &paired,
263 &connected, &trust, &string_var, &manufacturer_data_len, &manufacturer_var);
265 if (string_var == NULL) {
266 BT_ERR("invalid parameters in signal");
270 uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
272 len = g_variant_get_size(manufacturer_var);
274 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
276 dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
277 /* Fix : NULL_RETURNS */
278 if (dev_info == NULL) {
279 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
283 dev_info->rssi = rssi;
284 dev_info->paired = paired;
285 dev_info->connected = connected;
286 dev_info->trust = trust;
288 g_strlcpy(dev_info->device_name.name, name,
289 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
291 _bt_divide_device_class(&dev_info->device_class, dev_class);
293 _bt_convert_addr_string_to_type(dev_info->device_address.addr,
297 __bt_get_uuid_info(dev_info, uuids, uuid_count);
299 if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
300 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
301 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
303 dev_info->manufacturer_data.data_len = manufacturer_data_len;
304 if (manufacturer_data)
305 for (i = 0; i < manufacturer_data_len; i++)
306 dev_info->manufacturer_data.data[i] = manufacturer_data[i];
310 g_variant_unref(string_var);
311 g_variant_unref(manufacturer_var);
315 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
317 bluetooth_le_device_info_t *le_dev_info;
318 const char *address = NULL;
323 int adv_data_len = 0;
324 GVariant *adv_var = NULL;
325 const char *adv_data = NULL;
326 int scan_data_len = 0;
327 GVariant *scan_var = NULL;
328 const char *scan_data = NULL;
329 int result = BLUETOOTH_ERROR_NONE;
331 g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
332 &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
334 len = g_variant_get_size(adv_var);
336 adv_data = (char *)g_variant_get_data(adv_var);
338 len = g_variant_get_size(scan_var);
340 scan_data = (char *)g_variant_get_data(scan_var);
342 le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
343 /* Fix : NULL_RETURNS */
344 if (le_dev_info == NULL) {
345 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
348 _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
349 le_dev_info->addr_type = addr_type;
350 le_dev_info->rssi = rssi;
351 le_dev_info->adv_ind_data.data_len = adv_data_len;
353 for (i = 0; i < adv_data_len; i++)
355 le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
357 le_dev_info->scan_resp_data.data_len = scan_data_len;
359 for (i = 0; i < scan_data_len; i++)
361 le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
366 g_variant_unref(adv_var);
367 g_variant_unref(scan_var);
371 gboolean __bt_reliable_disable_cb(gpointer user_data)
374 bt_event_info_t *event_info = user_data;
376 _bt_set_le_scan_status(FALSE);
378 if (is_initialized != FALSE) {
379 if (is_adapter_enabled == TRUE) {
380 is_adapter_enabled = FALSE;
381 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
382 BLUETOOTH_ERROR_NONE, NULL,
383 event_info->cb, event_info->user_data);
384 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
385 BLUETOOTH_ERROR_NONE, NULL,
386 event_info->cb, event_info->user_data);
390 obex_server_id = BT_NO_SERVER;
391 __bt_remove_all_server();
392 __bt_remove_all_push_request_id();
394 _bt_rfcomm_server_free_all();
400 void __bt_adapter_event_filter(GDBusConnection *connection,
401 const gchar *sender_name,
402 const gchar *object_path,
403 const gchar *interface_name,
404 const gchar *signal_name,
405 GVariant *parameters,
408 bt_event_info_t *event_info;
409 int result = BLUETOOTH_ERROR_NONE;
411 event_info = (bt_event_info_t *)user_data;
412 ret_if(event_info == NULL);
414 if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
416 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
419 if (strcasecmp(signal_name, BT_ENABLED) == 0) {
420 BT_INFO("BT_ENABLED");
421 g_variant_get(parameters, "(i)", &result);
422 if (result == BLUETOOTH_ERROR_NONE) {
423 if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
424 BT_ERR("Set vconf failed");
426 if (vconf_set_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, 0) != 0)
427 BT_ERR("Set vconf failed");
429 if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 0) != 0)
430 BT_ERR("Set vconf failed");
433 is_adapter_enabled = TRUE;
435 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
437 event_info->cb, event_info->user_data);
438 } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
439 BT_INFO("BT_DISABLED");
441 /* Wait for the termining time of bt-service */
442 if (disable_timer_id > 0)
443 g_source_remove(disable_timer_id);
445 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
446 (GSourceFunc)__bt_reliable_disable_cb,
448 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
451 g_variant_get(parameters, "(in)", &result, &mode);
452 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
454 event_info->cb, event_info->user_data);
455 } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
458 g_variant_get(parameters, "(in)", &result, &timeout);
459 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
461 event_info->cb, event_info->user_data);
462 } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
463 gboolean connectable = FALSE;
465 g_variant_get(parameters, "(b)", &connectable);
466 BT_DBG("Connectable is changed : %d", connectable);
468 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
469 result, &connectable,
470 event_info->cb, event_info->user_data);
471 } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
472 char *adapter_name = NULL;
474 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
475 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
476 result, adapter_name,
477 event_info->cb, event_info->user_data);
478 } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
479 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
480 BLUETOOTH_ERROR_NONE, NULL,
481 event_info->cb, event_info->user_data);
482 } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
483 g_variant_get(parameters, "(i)", &result);
484 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
486 event_info->cb, event_info->user_data);
487 } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
490 g_variant_get(parameters, "(ii)", &result, &adv_handle);
491 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
493 event_info->cb, event_info->user_data);
494 } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
497 g_variant_get(parameters, "(ii)", &result, &adv_handle);
498 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
500 event_info->cb, event_info->user_data);
501 } else if (strcasecmp(signal_name, BT_ADVERTISING_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_ADVERTISING_MANUFACTURER_DATA_CHANGED,
512 event_info->cb, event_info->user_data);
514 g_variant_unref(var);
515 } else if (strcasecmp(signal_name, BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
516 GVariant *var = NULL;
520 g_variant_get(parameters, "(@ay)", &var);
521 len = g_variant_get_size(var);
522 data = (char *)g_variant_get_data(var);
524 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
526 event_info->cb, event_info->user_data);
528 g_variant_unref(var);
529 } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
530 GVariant *var = NULL;
534 g_variant_get(parameters, "(@ay)", &var);
535 len = g_variant_get_size(var);
536 data = (char *)g_variant_get_data(var);
538 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
540 event_info->cb, event_info->user_data);
542 g_variant_unref(var);
543 } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
545 bluetooth_device_info_t *device_info;
547 device_info = __bt_get_device_info_in_message(parameters,
549 ret_if(device_info == NULL);
551 if (strlen(device_info->device_name.name) > 0)
552 event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
554 event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
556 _bt_common_event_cb(event,
558 event_info->cb, event_info->user_data);
561 } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
562 bluetooth_device_info_t *device_info;
564 device_info = __bt_get_device_info_in_message(parameters,
566 ret_if(device_info == NULL);
568 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
570 event_info->cb, event_info->user_data);
573 } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
574 const char *address = NULL;
575 bluetooth_device_address_t dev_address = { {0} };
577 g_variant_get(parameters, "(i&s)", &result, &address);
579 _bt_convert_addr_string_to_type(dev_address.addr,
582 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
583 result, &dev_address,
584 event_info->cb, event_info->user_data);
585 } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
586 bluetooth_device_info_t *device_info;
587 bt_sdp_info_t sdp_info;
589 device_info = __bt_get_device_info_in_message(parameters,
591 ret_if(device_info == NULL);
593 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
595 sdp_info.service_index = device_info->service_index;
597 memcpy(&sdp_info.device_addr,
598 &device_info->device_address,
599 BLUETOOTH_ADDRESS_LENGTH);
601 memcpy(sdp_info.service_list_array,
602 device_info->service_list_array,
603 BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
605 memcpy(sdp_info.uuids,
607 BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
609 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
611 event_info->cb, event_info->user_data);
614 } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
615 gboolean ipsp_intialized = FALSE;
616 g_variant_get(parameters, "(b)", &ipsp_intialized);
618 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
620 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
621 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
622 event_info->cb, event_info->user_data);
623 } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
624 const char *address = NULL;
625 const char *name = NULL;
626 const char *str_passkey = NULL;
628 bluetooth_authentication_request_info_t auth_info;
629 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
631 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
633 g_strlcpy(auth_info.device_name.name, name,
634 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
635 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
637 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
639 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
641 event_info->cb, event_info->user_data);
642 } else if (strcasecmp(signal_name, BT_PIN_REQ_RECEIVED) == 0) {
643 const char *address = NULL;
644 const char *name = NULL;
646 bluetooth_authentication_request_info_t auth_info;
647 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
649 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
651 g_strlcpy(auth_info.device_name.name, name,
652 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
653 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
656 _bt_common_event_cb(BLUETOOTH_EVENT_PIN_REQUEST,
658 event_info->cb, event_info->user_data);
659 } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
660 const char *address = NULL;
661 const char *name = NULL;
663 bluetooth_authentication_request_info_t auth_info;
664 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
666 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
668 g_strlcpy(auth_info.device_name.name, name,
669 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
670 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
673 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
675 event_info->cb, event_info->user_data);
676 } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
677 const char *address = NULL;
678 const char *name = NULL;
679 const char *str_passkey = NULL;
681 bluetooth_authentication_request_info_t auth_info;
682 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
684 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
686 g_strlcpy(auth_info.device_name.name, name,
687 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
688 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
690 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
692 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
694 event_info->cb, event_info->user_data);
698 void __bt_adapter_le_event_filter(GDBusConnection *connection,
699 const gchar *sender_name,
700 const gchar *object_path,
701 const gchar *interface_name,
702 const gchar *signal_name,
703 GVariant *parameters,
706 bt_event_info_t *event_info;
707 int result = BLUETOOTH_ERROR_NONE;
709 event_info = (bt_event_info_t *)user_data;
710 ret_if(event_info == NULL);
712 if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
714 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
717 if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
718 BT_INFO("BT_LE_ENABLED");
719 g_variant_get(parameters, "(i)", &result);
720 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
722 event_info->cb, event_info->user_data);
723 } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
724 BT_INFO("BT_LE_DISABLED");
725 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
727 event_info->cb, event_info->user_data);
728 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
729 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
730 BLUETOOTH_ERROR_NONE, NULL,
731 event_info->cb, event_info->user_data);
732 } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
733 g_variant_get(parameters, "(i)", &result);
734 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
736 event_info->cb, event_info->user_data);
737 } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
738 bluetooth_le_device_info_t *le_device_info;
740 le_device_info = __bt_get_le_device_info_in_message(parameters,
742 ret_if(le_device_info == NULL);
744 _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
745 result, le_device_info,
746 event_info->cb, event_info->user_data);
748 g_free(le_device_info);
752 void __bt_device_event_filter(GDBusConnection *connection,
753 const gchar *sender_name,
754 const gchar *object_path,
755 const gchar *interface_name,
756 const gchar *signal_name,
757 GVariant *parameters,
760 bt_event_info_t *event_info;
761 int result = BLUETOOTH_ERROR_NONE;
763 event_info = (bt_event_info_t *)user_data;
764 ret_if(event_info == NULL);
767 gboolean gatt_interface = FALSE;
769 if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
770 gatt_interface = TRUE;
772 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
773 gatt_interface == FALSE)
775 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
776 gatt_interface == FALSE)
779 if (strcasecmp(object_path, BT_DEVICE_PATH) != 0)
781 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
785 ret_if(signal_name == NULL);
787 if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
788 const char *address = NULL;
789 bluetooth_device_address_t dev_address = { {0} };
790 BT_DBG("BT_GATT_CONNECTED");
791 g_variant_get(parameters, "(i&s)", &result, &address);
793 _bt_convert_addr_string_to_type(dev_address.addr, address);
794 BT_DBG("Sending Event to Framework");
795 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
796 result, &dev_address,
797 event_info->cb, event_info->user_data);
798 } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
799 const char *address = NULL;
800 bluetooth_device_address_t dev_address = { {0} };
801 BT_DBG("BT_GATT_DISCONNECTED");
802 g_variant_get(parameters, "(i&s)", &result, &address);
804 _bt_convert_addr_string_to_type(dev_address.addr, address);
805 BT_DBG("Sending Event to Framework");
806 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
807 result, &dev_address,
808 event_info->cb, event_info->user_data);
810 } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
812 } else if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) {
814 const char *char_handle = NULL;
816 const char * value = NULL;
817 GVariant *char_value_var = NULL;
818 bt_gatt_char_value_t char_val = { 0, };
819 BT_DBG("BT_GATT_CHAR_VAL_CHANGED");
821 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
823 len = g_variant_get_size(char_value_var);
825 value = (char *)g_variant_get_data(char_value_var);
827 char_val.char_handle = g_strdup(char_handle);
828 char_val.val_len = len;
829 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
830 if (char_val.val_len > 0 && value != NULL) {
831 char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
832 /* Fix : NULL_RETURNS */
833 if (char_val.char_value == NULL) {
834 BT_ERR("BLUETOOTH_ERROR_OUT_OF_MEMORY");
835 g_free(char_val.char_handle);
837 g_variant_unref(char_value_var);
840 memcpy(char_val.char_value, value, len);
841 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
843 event_info->cb, event_info->user_data);
844 g_free(char_val.char_value);
846 g_variant_unref(char_value_var);
848 g_free(char_val.char_handle);
849 } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
850 const char *address = NULL;
851 unsigned char addr_type;
852 bt_connection_info_t conn_info;
853 bluetooth_device_address_t dev_address = { {0} };
854 BT_DBG("BT_DEVICE_CONNECTED");
855 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
857 _bt_convert_addr_string_to_type(dev_address.addr,
860 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
862 memcpy(conn_info.device_addr.addr,
864 BLUETOOTH_ADDRESS_LENGTH);
866 conn_info.addr_type = addr_type;
867 conn_info.disc_reason = 0;
868 BT_DBG("Sending Event to Framework");
869 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
871 event_info->cb, event_info->user_data);
873 } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
874 const char *address = NULL;
875 unsigned char addr_type;
876 bt_connection_info_t conn_info;
877 bluetooth_device_address_t dev_address = { {0} };
878 BT_DBG("BT_DEVICE_DISCONNECTED");
879 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
881 _bt_convert_addr_string_to_type(dev_address.addr,
884 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
886 memcpy(conn_info.device_addr.addr,
888 BLUETOOTH_ADDRESS_LENGTH);
890 conn_info.addr_type = addr_type;
891 conn_info.disc_reason = result;
892 BT_DBG("Sending Event to Framework");
893 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
895 event_info->cb, event_info->user_data);
897 } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
898 bt_rssi_enabled_t enabled = { 0, };
901 gboolean rssi_enabled = FALSE;
903 g_variant_get(parameters, "(isib)", &result, &address,
904 &link_type, &rssi_enabled);
906 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
907 address, link_type, rssi_enabled);
908 enabled.address = address;
909 enabled.link_type = link_type;
910 enabled.rssi_enabled = rssi_enabled;
912 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
914 event_info->cb, event_info->user_data);
915 } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
920 bt_rssi_alert_t alert = { 0, };
922 g_variant_get(parameters, "(isiii)", &result, &address,
923 &link_type, &alert_type, &rssi_dbm);
925 alert.alert_type = alert_type;
926 alert.rssi_dbm = rssi_dbm;
927 alert.address = address;
928 alert.link_type = link_type;
929 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
930 address, link_type, alert_type, rssi_dbm);
931 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
933 event_info->cb, event_info->user_data);
934 } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
938 bt_raw_rssi_t raw_rssi = { 0, };
940 g_variant_get(parameters, "(isii)", &result,
941 &address, &link_type, &rssi_dbm);
943 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
944 address, link_type, rssi_dbm);
946 raw_rssi.rssi_dbm = rssi_dbm;
947 raw_rssi.address = address;
948 raw_rssi.link_type = link_type;
950 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
952 event_info->cb, event_info->user_data);
953 } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
954 const char *address = NULL;
955 bluetooth_device_address_t dev_address = { {0} };
957 g_variant_get(parameters, "(i&s)", &result, &address);
959 _bt_convert_addr_string_to_type(dev_address.addr,
962 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
963 result, &dev_address,
964 event_info->cb, event_info->user_data);
965 } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
966 const char *address = NULL;
967 bluetooth_device_address_t dev_address = { {0} };
969 g_variant_get(parameters, "(i&s)", &result, &address);
971 _bt_convert_addr_string_to_type(dev_address.addr,
974 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
975 result, &dev_address,
976 event_info->cb, event_info->user_data);
977 } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
978 const char *address = NULL;
979 bluetooth_device_address_t dev_address = { {0} };
981 BT_DBG("BT_IPSP_CONNECTED");
982 g_variant_get(parameters, "(i&s)", &result, &address);
984 _bt_convert_addr_string_to_type(dev_address.addr, address);
986 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
987 result, &dev_address,
988 event_info->cb, event_info->user_data);
989 } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
990 const char *address = NULL;
991 bluetooth_device_address_t dev_address = { {0} };
992 BT_DBG("BT_IPSP_DISCONNECTED");
994 g_variant_get(parameters, "(i&s)", &result, &address);
996 _bt_convert_addr_string_to_type(dev_address.addr, address);
998 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
999 result, &dev_address,
1000 event_info->cb, event_info->user_data);
1001 } else if (strcasecmp(signal_name, BT_IPSP_BT_INTERFACE_INFO) == 0) {
1002 const char *address = NULL;
1003 const char *if_name = NULL;
1004 bt_ipsp_interface_info_t ipsp_iface_info;
1005 memset(&ipsp_iface_info, 0, sizeof(ipsp_iface_info));
1007 BT_DBG("BT_IPSP_BT_INTERFACE_INFO");
1008 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1010 _bt_convert_addr_string_to_type(ipsp_iface_info.btaddr.addr, address);
1011 memcpy(ipsp_iface_info.if_name, if_name, 16);
1013 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO,
1014 result, &ipsp_iface_info,
1015 event_info->cb, event_info->user_data);
1016 } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1017 const char *address = NULL;
1018 bluetooth_device_address_t dev_address = { {0} };
1023 bt_le_data_length_params_t params;
1025 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1027 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1028 tx_octets, tx_time, rx_octets, rx_time);
1030 params.max_tx_octets = tx_octets;
1031 params.max_tx_time = tx_time;
1032 params.max_rx_octets = rx_octets;
1033 params.max_rx_time = rx_time;
1035 _bt_convert_addr_string_to_type(dev_address.addr, address);
1037 memcpy(¶ms.device_address,
1038 &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1040 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1041 result, ¶ms, event_info->cb, event_info->user_data);
1045 void __bt_hid_event_filter(GDBusConnection *connection,
1046 const gchar *sender_name,
1047 const gchar *object_path,
1048 const gchar *interface_name,
1049 const gchar *signal_name,
1050 GVariant *parameters,
1053 bt_event_info_t *event_info;
1054 int result = BLUETOOTH_ERROR_NONE;
1056 event_info = (bt_event_info_t *)user_data;
1057 ret_if(event_info == NULL);
1059 if (strcasecmp(object_path, BT_HID_PATH) != 0)
1061 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1064 ret_if(signal_name == NULL);
1066 if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1067 const char *address = NULL;
1068 bluetooth_device_address_t dev_address = { {0} };
1070 g_variant_get(parameters, "(i&s)", &result, &address);
1072 _bt_convert_addr_string_to_type(dev_address.addr,
1075 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1076 result, &dev_address,
1077 event_info->cb, event_info->user_data);
1078 } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1079 const char *address = NULL;
1080 bluetooth_device_address_t dev_address = { {0} };
1082 g_variant_get(parameters, "(i&s)", &result, &address);
1084 BT_DBG("address: %s", address);
1086 _bt_convert_addr_string_to_type(dev_address.addr,
1089 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1090 result, &dev_address,
1091 event_info->cb, event_info->user_data);
1095 void __bt_headset_event_filter(GDBusConnection *connection,
1096 const gchar *sender_name,
1097 const gchar *object_path,
1098 const gchar *interface_name,
1099 const gchar *signal_name,
1100 GVariant *parameters,
1103 bt_event_info_t *event_info;
1104 int result = BLUETOOTH_ERROR_NONE;
1105 event_info = (bt_event_info_t *)user_data;
1106 ret_if(event_info == NULL);
1108 if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1110 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1113 ret_if(signal_name == NULL);
1115 if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1116 char *address = NULL;
1118 g_variant_get(parameters, "(i&s)", &result, &address);
1120 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1122 event_info->cb, event_info->user_data);
1123 } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1124 char *address = NULL;
1126 g_variant_get(parameters, "(i&s)", &result, &address);
1128 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1130 event_info->cb, event_info->user_data);
1131 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1132 char *address = NULL;
1134 g_variant_get(parameters, "(i&s)", &result, &address);
1136 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1138 event_info->cb, event_info->user_data);
1139 } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1140 char *address = NULL;
1142 g_variant_get(parameters, "(i&s)", &result, &address);
1144 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1146 event_info->cb, event_info->user_data);
1147 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1148 char *address = NULL;
1150 g_variant_get(parameters, "(i&s)", &result, &address);
1151 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1153 event_info->cb, event_info->user_data);
1154 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1155 char *address = NULL;
1157 g_variant_get(parameters, "(i&s)", &result, &address);
1159 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1161 event_info->cb, event_info->user_data);
1162 } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1165 char *address = NULL;
1167 g_variant_get(parameters, "(i&sq)", &result, &address,
1169 gain = (unsigned int)spkr_gain;
1171 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1173 event_info->cb, event_info->user_data);
1174 } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1177 char *address = NULL;
1179 g_variant_get(parameters, "(i&sq)", &result,
1180 &address, &mic_gain);
1181 gain = (unsigned int)mic_gain;
1183 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1185 event_info->cb, event_info->user_data);
1189 void __bt_hid_device_event_filter(GDBusConnection *connection,
1190 const gchar *sender_name,
1191 const gchar *object_path,
1192 const gchar *interface_name,
1193 const gchar *signal_name,
1194 GVariant *parameters,
1197 bt_event_info_t *event_info;
1198 int result = BLUETOOTH_ERROR_NONE;
1200 event_info = (bt_event_info_t *)user_data;
1201 ret_if(event_info == NULL);
1203 if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1205 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1208 ret_if(signal_name == NULL);
1210 if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1211 const char *address = NULL;
1212 bluetooth_device_address_t dev_address = { {0} };
1214 g_variant_get(parameters, "(i&s)", &result, &address);
1216 _bt_convert_addr_string_to_type(dev_address.addr,
1219 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1220 result, &dev_address,
1221 event_info->cb, event_info->user_data);
1222 } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1223 const char *address = NULL;
1224 bluetooth_device_address_t dev_address = { {0} };
1226 g_variant_get(parameters, "(i&s)", &result, &address);
1228 BT_DBG("address: %s", address);
1230 _bt_convert_addr_string_to_type(dev_address.addr,
1233 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1234 result, &dev_address,
1235 event_info->cb, event_info->user_data);
1238 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1239 const gchar *sender_name,
1240 const gchar *object_path,
1241 const gchar *interface_name,
1242 const gchar *signal_name,
1243 GVariant *parameters,
1246 bt_event_info_t *event_info;
1247 int result = BLUETOOTH_ERROR_NONE;
1248 event_info = (bt_event_info_t *)user_data;
1249 ret_if(event_info == NULL);
1251 if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1253 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1256 ret_if(signal_name == NULL);
1258 if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1259 char *address = NULL;
1261 g_variant_get(parameters, "(i&s)", &result, &address);
1262 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1264 event_info->cb, event_info->user_data);
1265 } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1266 char *address = NULL;
1268 g_variant_get(parameters, "(i&s)", &result, &address);
1270 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1272 event_info->cb, event_info->user_data);
1276 void __bt_network_event_filter(GDBusConnection *connection,
1277 const gchar *sender_name,
1278 const gchar *object_path,
1279 const gchar *interface_name,
1280 const gchar *signal_name,
1281 GVariant *parameters,
1284 bt_event_info_t *event_info;
1285 int result = BLUETOOTH_ERROR_NONE;
1286 event_info = (bt_event_info_t *)user_data;
1287 ret_if(event_info == NULL);
1289 if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1291 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1294 ret_if(signal_name == NULL);
1296 if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1297 const char *address = NULL;
1298 bluetooth_device_address_t dev_address = { {0} };
1300 g_variant_get(parameters, "(i&s)", &result, &address);
1302 _bt_convert_addr_string_to_type(dev_address.addr,
1305 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1306 result, &dev_address,
1307 event_info->cb, event_info->user_data);
1308 } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1309 const char *address = NULL;
1310 bluetooth_device_address_t dev_address = { {0} };
1312 g_variant_get(parameters, "(i&s)", &result, &address);
1314 _bt_convert_addr_string_to_type(dev_address.addr,
1317 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1318 result, &dev_address,
1319 event_info->cb, event_info->user_data);
1320 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1321 const char *device = NULL;
1322 const char *address = NULL;
1323 bluetooth_network_device_info_t network_info;
1325 g_variant_get(parameters, "(i&s&s)", &result,
1328 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1330 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1333 _bt_print_device_address_t(&network_info.device_address);
1334 g_strlcpy(network_info.interface_name, device,
1335 sizeof(network_info.interface_name));
1337 DBG_SECURE("Interface: %s", network_info.interface_name);
1339 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1340 result, &network_info,
1341 event_info->cb, event_info->user_data);
1342 } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1343 const char *device = NULL;
1344 const char *address = NULL;
1345 bluetooth_network_device_info_t network_info;
1347 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1349 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1351 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1354 _bt_print_device_address_t(&network_info.device_address);
1356 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1357 result, &network_info,
1358 event_info->cb, event_info->user_data);
1362 void __bt_avrcp_event_filter(GDBusConnection *connection,
1363 const gchar *sender_name,
1364 const gchar *object_path,
1365 const gchar *interface_name,
1366 const gchar *signal_name,
1367 GVariant *parameters,
1370 bt_event_info_t *event_info;
1371 int result = BLUETOOTH_ERROR_NONE;
1372 event_info = (bt_event_info_t *)user_data;
1373 ret_if(event_info == NULL);
1375 if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1377 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1380 ret_if(signal_name == NULL);
1382 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1383 char *address = NULL;
1385 g_variant_get(parameters, "(i&s)", &result, &address);
1387 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1389 event_info->cb, event_info->user_data);
1390 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1391 char *address = NULL;
1393 g_variant_get(parameters, "(i&s)", &result, &address);
1395 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1397 event_info->cb, event_info->user_data);
1398 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1399 unsigned int status;
1401 g_variant_get(parameters, "(u)", &status);
1402 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1404 event_info->cb, event_info->user_data);
1405 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1406 unsigned int status;
1408 g_variant_get(parameters, "(u)", &status);
1409 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1411 event_info->cb, event_info->user_data);
1412 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1413 unsigned int status;
1415 g_variant_get(parameters, "(u)", &status);
1416 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1418 event_info->cb, event_info->user_data);
1419 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1420 unsigned int status;
1422 g_variant_get(parameters, "(u)", &status);
1423 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1425 event_info->cb, event_info->user_data);
1429 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1430 const gchar *sender_name,
1431 const gchar *object_path,
1432 const gchar *interface_name,
1433 const gchar *signal_name,
1434 GVariant *parameters,
1437 bt_event_info_t *event_info;
1438 int result = BLUETOOTH_ERROR_NONE;
1439 event_info = (bt_event_info_t *)user_data;
1440 ret_if(event_info == NULL);
1442 if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1444 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1447 ret_if(signal_name == NULL);
1449 if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1450 char *address = NULL;
1452 g_variant_get(parameters, "(i&s)", &result, &address);
1454 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1456 event_info->cb, event_info->user_data);
1457 } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1458 char *address = NULL;
1460 g_variant_get(parameters, "(i&s)", &result, &address);
1462 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1464 event_info->cb, event_info->user_data);
1465 } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1466 unsigned int status;
1468 g_variant_get(parameters, "(u)", &status);
1469 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1471 event_info->cb, event_info->user_data);
1472 } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1473 unsigned int status;
1475 g_variant_get(parameters, "(u)", &status);
1476 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1478 event_info->cb, event_info->user_data);
1479 } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1480 unsigned int status;
1482 g_variant_get(parameters, "(u)", &status);
1483 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1485 event_info->cb, event_info->user_data);
1486 } else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1487 unsigned int status;
1489 g_variant_get(parameters, "(u)", &status);
1490 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1492 event_info->cb, event_info->user_data);
1493 } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1494 unsigned int status;
1496 g_variant_get(parameters, "(u)", &status);
1497 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1499 event_info->cb, event_info->user_data);
1500 } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1501 unsigned int status;
1503 g_variant_get(parameters, "(u)", &status);
1504 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1506 event_info->cb, event_info->user_data);
1507 } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1508 media_metadata_attributes_t metadata;
1513 unsigned int total_tracks;
1514 unsigned int number;
1515 unsigned int duration;
1517 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1518 &artist, &album, &genre,
1519 &total_tracks, &number,
1521 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1523 metadata.title = title;
1524 metadata.artist = artist;
1525 metadata.album = album;
1526 metadata.genre = genre;
1527 metadata.total_tracks = total_tracks;
1528 metadata.number = number;
1529 metadata.duration = (int64_t)duration;
1531 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1533 event_info->cb, event_info->user_data);
1537 void __bt_opp_client_event_filter(GDBusConnection *connection,
1538 const gchar *sender_name,
1539 const gchar *object_path,
1540 const gchar *interface_name,
1541 const gchar *signal_name,
1542 GVariant *parameters,
1545 bt_event_info_t *event_info;
1546 int result = BLUETOOTH_ERROR_NONE;
1547 event_info = (bt_event_info_t *)user_data;
1548 ret_if(event_info == NULL);
1550 if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1552 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1555 ret_if(signal_name == NULL);
1557 if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1558 const char *address = NULL;
1560 bluetooth_device_address_t dev_address = { {0} };
1562 g_variant_get(parameters, "(i&si)", &result,
1563 &address, &request_id);
1565 if (__bt_is_request_id_exist(request_id) == FALSE) {
1566 BT_ERR("Different request id!");
1570 _bt_convert_addr_string_to_type(dev_address.addr,
1573 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1574 result, &dev_address,
1575 event_info->cb, event_info->user_data);
1577 if (result != BLUETOOTH_ERROR_NONE) {
1578 __bt_remove_push_request_id(request_id);
1580 } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1581 const char *address = NULL;
1583 bluetooth_device_address_t dev_address = { {0} };
1585 g_variant_get(parameters, "(i&si)", &result, &address,
1588 if (__bt_is_request_id_exist(request_id) == FALSE) {
1589 BT_ERR("Different request id!");
1593 _bt_convert_addr_string_to_type(dev_address.addr,
1596 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1597 result, &dev_address,
1598 event_info->cb, event_info->user_data);
1600 __bt_remove_push_request_id(request_id);
1601 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1602 const char *file_name = NULL;
1605 bt_opc_transfer_info_t transfer_info;
1607 g_variant_get(parameters, "(i&sti)", &result, &file_name,
1608 &size, &request_id);
1610 if (__bt_is_request_id_exist(request_id) == FALSE) {
1611 BT_ERR("Different request id!");
1615 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1617 transfer_info.filename = g_strdup(file_name);
1618 transfer_info.size = size;
1620 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1621 result, &transfer_info,
1622 event_info->cb, event_info->user_data);
1624 g_free(transfer_info.filename);
1625 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1626 const char *file_name = NULL;
1630 bt_opc_transfer_info_t transfer_info;
1632 g_variant_get(parameters, "(i&stii)", &result,
1633 &file_name, &size, &progress, &request_id);
1635 if (__bt_is_request_id_exist(request_id) == FALSE) {
1636 BT_ERR("Different request id!");
1640 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1642 transfer_info.filename = g_strdup(file_name);
1643 transfer_info.size = size;
1644 transfer_info.percentage = progress;
1646 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1647 result, &transfer_info,
1648 event_info->cb, event_info->user_data);
1650 g_free(transfer_info.filename);
1651 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1652 const char *file_name = NULL;
1655 bt_opc_transfer_info_t transfer_info;
1657 g_variant_get(parameters, "(i&sti)", &result,
1658 &file_name, &size, &request_id);
1660 if (__bt_is_request_id_exist(request_id) == FALSE) {
1661 BT_ERR("Different request id!");
1665 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1667 transfer_info.filename = g_strdup(file_name);
1668 transfer_info.size = size;
1670 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1671 result, &transfer_info,
1672 event_info->cb, event_info->user_data);
1674 g_free(transfer_info.filename);
1678 void __bt_opp_server_event_filter(GDBusConnection *connection,
1679 const gchar *sender_name,
1680 const gchar *object_path,
1681 const gchar *interface_name,
1682 const gchar *signal_name,
1683 GVariant *parameters,
1686 bt_event_info_t *event_info;
1687 int result = BLUETOOTH_ERROR_NONE;
1688 event_info = (bt_event_info_t *)user_data;
1689 ret_if(event_info == NULL);
1691 if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1693 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1696 ret_if(signal_name == NULL);
1698 if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1699 /* Native only event */
1700 const char *file_name = NULL;
1702 bt_obex_server_authorize_into_t auth_info;
1704 g_variant_get(parameters, "(i&st)", &result, &file_name, &size);
1706 /* OSP server: Don't get this event */
1707 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1709 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1711 auth_info.filename = g_strdup(file_name);
1712 auth_info.length = size;
1714 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1716 event_info->cb, event_info->user_data);
1718 g_free(auth_info.filename);
1719 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1720 /* OSP only event */
1721 const char *address = NULL;
1722 const char *name = NULL;
1723 bluetooth_device_address_t dev_address = { {0} };
1725 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1727 /* Native server: Don't get this event */
1728 ret_if(obex_server_id == BT_NATIVE_SERVER);
1730 _bt_convert_addr_string_to_type(dev_address.addr,
1733 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1734 result, &dev_address,
1735 event_info->cb, event_info->user_data);
1736 } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1738 g_variant_get(parameters, "(i)", &result);
1740 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1741 result, NULL, event_info->cb,
1742 event_info->user_data);
1743 } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1745 g_variant_get(parameters, "(i)", &result);
1747 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1748 result, NULL, event_info->cb,
1749 event_info->user_data);
1750 } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1751 const char *file_name = NULL;
1752 const char *type = NULL;
1753 int transfer_id = 0;
1754 int server_type = 0; /* bt_server_type_t */
1756 bt_obex_server_transfer_info_t transfer_info;
1758 g_variant_get(parameters, "(i&s&stii)", &result, &file_name,
1759 &type, &size, &transfer_id, &server_type);
1761 /* Other server's event */
1762 ret_if(obex_server_id != server_type &&
1763 server_type != BT_FTP_SERVER);
1765 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1767 transfer_info.filename = g_strdup(file_name);
1768 transfer_info.type = g_strdup(type);
1769 transfer_info.file_size = size;
1770 transfer_info.transfer_id = transfer_id;
1771 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1772 FTP_SERVER : OPP_SERVER;
1774 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1775 result, &transfer_info,
1776 event_info->cb, event_info->user_data);
1778 g_free(transfer_info.filename);
1779 g_free(transfer_info.type);
1780 } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1781 const char *file_name = NULL;
1782 const char *type = NULL;
1783 int transfer_id = 0;
1785 int server_type = 0; /* bt_server_type_t */
1787 bt_obex_server_transfer_info_t transfer_info;
1789 g_variant_get(parameters, "(i&s&stiii)", &result, &file_name,
1790 &type, &size, &transfer_id,
1791 &progress, &server_type);
1793 /* Other server's event */
1794 ret_if(obex_server_id != server_type &&
1795 server_type != BT_FTP_SERVER);
1797 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1799 transfer_info.filename = g_strdup(file_name);
1800 transfer_info.type = g_strdup(type);
1801 transfer_info.file_size = size;
1802 transfer_info.transfer_id = transfer_id;
1803 transfer_info.percentage = progress;
1804 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1805 FTP_SERVER : OPP_SERVER;
1807 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1808 result, &transfer_info,
1809 event_info->cb, event_info->user_data);
1811 g_free(transfer_info.filename);
1812 g_free(transfer_info.type);
1813 } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1814 const char *file_name = NULL;
1815 const char *device_name = NULL;
1816 const char *type = NULL;
1817 const char *file_path;
1818 int transfer_id = 0;
1819 int server_type = 0; /* bt_server_type_t */
1821 bt_obex_server_transfer_info_t transfer_info;
1823 g_variant_get(parameters, "(i&s&s&s&stii)", &result, &file_name,
1824 &type, &device_name, &file_path, &size,
1825 &transfer_id, &server_type);
1827 /* Other server's event */
1828 ret_if(obex_server_id != server_type &&
1829 server_type != BT_FTP_SERVER);
1831 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1833 transfer_info.filename = g_strdup(file_name);
1834 transfer_info.type = g_strdup(type);
1835 transfer_info.device_name = g_strdup(device_name);
1836 transfer_info.file_path = g_strdup(file_path);
1837 transfer_info.file_size = size;
1838 transfer_info.transfer_id = transfer_id;
1839 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1840 FTP_SERVER : OPP_SERVER;
1842 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1843 result, &transfer_info,
1844 event_info->cb, event_info->user_data);
1846 g_free(transfer_info.filename);
1847 g_free(transfer_info.type);
1848 g_free(transfer_info.device_name);
1849 g_free(transfer_info.file_path);
1853 void __bt_pbap_client_event_filter(GDBusConnection *connection,
1854 const gchar *sender_name,
1855 const gchar *object_path,
1856 const gchar *interface_name,
1857 const gchar *signal_name,
1858 GVariant *parameters,
1861 bt_event_info_t *event_info;
1862 int result = BLUETOOTH_ERROR_NONE;
1863 event_info = (bt_event_info_t *)user_data;
1864 ret_if(event_info == NULL);
1866 if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
1868 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1871 ret_if(signal_name == NULL);
1872 BT_DBG("Type: %s", g_variant_get_type_string(parameters));
1873 if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
1874 bt_pbap_connected_t connected = { { { 0 }, }, };
1875 char *address = NULL;
1877 g_variant_get(parameters, "(is)", &result, &address);
1878 BT_DBG("address: %s", address);
1880 _bt_convert_addr_string_to_type(connected.btaddr.addr,
1883 connected.connected = 1;
1885 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
1887 event_info->cb, event_info->user_data);
1888 } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
1889 bt_pbap_connected_t connected = { { { 0 }, }, };
1890 char *address = NULL;
1892 g_variant_get(parameters, "(is)", &result, &address);
1893 BT_DBG("address: %s", address);
1895 _bt_convert_addr_string_to_type(connected.btaddr.addr,
1898 connected.connected = 0;
1900 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
1902 event_info->cb, event_info->user_data);
1903 } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
1904 bt_pbap_connected_t disconnected = { { { 0 }, }, };
1905 char *address = NULL;
1907 g_variant_get(parameters, "(is)", &result, &address);
1908 BT_DBG("address: %s", address);
1910 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
1912 disconnected.connected = 0;
1914 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
1915 result, &disconnected,
1916 event_info->cb, event_info->user_data);
1917 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
1918 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
1919 char *address = NULL;
1922 g_variant_get(parameters, "(isi)", &result, &address, &size);
1924 BT_DBG("address: %s", address);
1925 BT_DBG("size: %d", size);
1927 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
1929 pb_size.size = size;
1931 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
1933 event_info->cb, event_info->user_data);
1934 } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
1935 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
1936 char *address = NULL;
1937 char *vcf_file = NULL;
1940 g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
1942 BT_DBG("address: %s", address);
1943 BT_DBG("vcf_file: %s", vcf_file);
1944 BT_DBG("success: %d", success);
1946 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
1948 pb_pull.vcf_file = vcf_file;
1949 pb_pull.success = success;
1950 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
1952 event_info->cb, event_info->user_data);
1953 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
1954 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
1955 char *address = NULL;
1957 gchar **list = NULL;
1958 GVariant *string_var;
1962 g_variant_get(parameters, "(isv)", &result, &address, &string_var);
1964 list = (gchar **)g_variant_get_strv(string_var, &count);
1967 BT_DBG("address: %s", address);
1968 BT_DBG("result: %d", result);
1969 BT_DBG("count: %d", count);
1970 for (i = 0; i < count; i++)
1971 BT_DBG("%s", list[i]);
1972 BT_DBG("success: %d", success);
1974 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
1976 vc_list.vcards = list;
1977 vc_list.length = count;
1978 vc_list.success = success;
1979 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
1981 event_info->cb, event_info->user_data);
1983 g_variant_unref(string_var);
1985 } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
1986 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
1987 char *address = NULL;
1988 char *vcf_file = NULL;
1991 g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
1993 BT_DBG("address: %s", address);
1994 BT_DBG("vcf_file: %s", vcf_file);
1995 BT_DBG("success: %d", success);
1997 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr,
1999 vc_pull.vcf_file = vcf_file;
2000 vc_pull.success = success;
2001 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2003 event_info->cb, event_info->user_data);
2004 } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2005 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2006 char *address = NULL;
2008 gchar **list = NULL;
2009 GVariant *string_var;
2013 g_variant_get(parameters, "(is@as)", &result, &address, &string_var);
2015 list = (gchar **)g_variant_get_strv(string_var, &count);
2017 BT_DBG("address: %s", address);
2018 for (i = 0; i < count; i++)
2019 BT_DBG("%s", list[i]);
2020 BT_DBG("success: %d", success);
2022 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2024 vc_list.vcards = list;
2025 vc_list.length = count;
2026 vc_list.success = success;
2027 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2029 event_info->cb, event_info->user_data);
2031 g_variant_unref(string_var);
2036 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2037 const gchar *sender_name,
2038 const gchar *object_path,
2039 const gchar *interface_name,
2040 const gchar *signal_name,
2041 GVariant *parameters,
2044 bt_event_info_t *event_info;
2045 int result = BLUETOOTH_ERROR_NONE;
2046 event_info = (bt_event_info_t *)user_data;
2047 ret_if(event_info == NULL);
2049 if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2051 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2054 ret_if(signal_name == NULL);
2056 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2057 const char *address = NULL;
2058 const char *uuid = NULL;
2060 bluetooth_rfcomm_connection_t conn_info;
2062 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2065 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2066 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2067 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2068 conn_info.socket_fd = socket_fd;
2069 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2072 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2074 event_info->cb, event_info->user_data);
2075 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2076 const char *address = NULL;
2077 const char *uuid = NULL;
2079 bluetooth_rfcomm_disconnection_t disconn_info;
2081 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2084 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2085 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2086 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2087 disconn_info.socket_fd = socket_fd;
2088 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2091 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2092 result, &disconn_info,
2093 event_info->cb, event_info->user_data);
2094 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2098 bluetooth_rfcomm_received_data_t data_r;
2101 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2104 buffer_len = g_variant_get_size(byte_var);
2105 buffer = (char *) g_variant_get_data(byte_var);
2107 data_r.socket_fd = socket_fd;
2108 data_r.buffer_size = buffer_len;
2109 data_r.buffer = buffer;
2111 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2113 event_info->cb, event_info->user_data);
2114 g_variant_unref(byte_var);
2118 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2119 const gchar *sender_name,
2120 const gchar *object_path,
2121 const gchar *interface_name,
2122 const gchar *signal_name,
2123 GVariant *parameters,
2126 bt_event_info_t *event_info;
2127 int result = BLUETOOTH_ERROR_NONE;
2128 event_info = (bt_event_info_t *)user_data;
2129 ret_if(event_info == NULL);
2131 if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2133 if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2136 ret_if(signal_name == NULL);
2138 if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2139 const char *address = NULL;
2140 const char *uuid = NULL;
2142 bluetooth_rfcomm_connection_t conn_info;
2144 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2147 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2148 conn_info.device_role = RFCOMM_ROLE_SERVER;
2149 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2150 conn_info.socket_fd = socket_fd;
2151 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2154 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2156 event_info->cb, event_info->user_data);
2157 } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2158 const char *address = NULL;
2159 const char *uuid = NULL;
2161 bluetooth_rfcomm_disconnection_t disconn_info;
2163 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2166 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2167 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2168 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2169 disconn_info.socket_fd = socket_fd;
2170 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2173 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2174 result, &disconn_info,
2175 event_info->cb, event_info->user_data);
2176 } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2177 /* OSP only event */
2178 bluetooth_rfcomm_connection_request_t req_ind;
2179 char *address = NULL;
2185 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2186 &uuid, &name, &path, &socket_fd);
2188 if (_check_uuid_path(path, uuid) == FALSE)
2191 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2192 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2195 req_ind.socket_fd = socket_fd;
2197 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2199 event_info->cb, event_info->user_data);
2200 } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2201 /* OSP only event */
2204 g_variant_get(parameters, "(in)", &result, &socket_fd);
2206 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2208 _bt_remove_server(socket_fd);
2209 } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2210 char *buffer = NULL;
2213 bluetooth_rfcomm_received_data_t data_r;
2216 g_variant_get(parameters, "(in@ay)", &result,
2217 &socket_fd, &byte_var);
2219 buffer_len = g_variant_get_size(byte_var);
2220 buffer = (char *) g_variant_get_data(byte_var);
2222 data_r.socket_fd = socket_fd;
2223 data_r.buffer_size = buffer_len;
2224 data_r.buffer = buffer;
2226 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2228 event_info->cb, event_info->user_data);
2229 g_variant_unref(byte_var);
2233 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2234 const gchar *sender_name,
2235 const gchar *object_path,
2236 const gchar *interface_name,
2237 const gchar *signal_name,
2238 GVariant *parameters,
2243 bt_event_info_t *event_info;
2244 int result = BLUETOOTH_ERROR_NONE;
2245 event_info = (bt_event_info_t *)user_data;
2246 ret_if(event_info == NULL);
2249 if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2251 if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2254 ret_if(signal_name == NULL);
2256 BT_DBG("%s", signal_name);
2257 if (strcasecmp(signal_name, "Connected") == 0) {
2258 char *address = NULL;
2260 g_variant_get(parameters, "(s)", &address);
2261 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2263 event_info->cb, event_info->user_data);
2264 } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2265 char *address = NULL;
2267 g_variant_get(parameters, "(s)", &address);
2268 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2270 event_info->cb, event_info->user_data);
2271 } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2272 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2274 event_info->cb, event_info->user_data);
2275 } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2276 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2278 event_info->cb, event_info->user_data);
2279 } else if (strcasecmp(signal_name, "Ring") == 0) {
2280 char *phoneno = NULL;
2282 g_variant_get(parameters, "(&s)", &phoneno);
2284 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2286 event_info->cb, event_info->user_data);
2287 } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2288 char *phoneno = NULL;
2290 g_variant_get(parameters, "(&s)", &phoneno);
2292 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2294 event_info->cb, event_info->user_data);
2295 } else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2296 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2298 event_info->cb, event_info->user_data);
2299 } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2300 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2302 event_info->cb, event_info->user_data);
2303 } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2304 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2306 event_info->cb, event_info->user_data);
2307 } else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2308 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2310 event_info->cb, event_info->user_data);
2311 } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2312 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2314 event_info->cb, event_info->user_data);
2315 } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2316 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2318 event_info->cb, event_info->user_data);
2319 } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2321 GVariant *var_data = NULL;
2322 char *number = NULL;
2323 int idx, dir, status, mpart;
2324 bt_hf_call_list_s *handle = NULL;
2326 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2328 BT_DBG("call count : %d", call_count);
2331 GVariantIter *iter = NULL;
2332 __bt_call_list_create(&handle);
2334 g_variant_get(var_data, "a(siiii)", &iter);
2335 while (g_variant_iter_loop(iter, "(siiii)", &number,
2336 &dir, &status, &mpart, &idx)) {
2337 BT_DBG("call number:%s, dir:%d, status : %d",
2338 number, dir, status);
2339 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2340 __bt_call_list_add(handle, number, dir,
2341 status, mpart, idx);
2343 g_variant_iter_free(iter);
2344 g_variant_unref(var_data);
2347 if (handle && (call_count == g_list_length(handle->list))) {
2348 handle->count = call_count;
2349 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2351 event_info->cb, event_info->user_data);
2353 BT_ERR(" Mismatch in call count : %d", call_count);
2356 __bt_call_list_destroy(handle);
2357 } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2359 g_variant_get(parameters, "(i)", &status);
2360 BT_DBG("status = [%d]\n", status);
2362 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2364 event_info->cb, event_info->user_data);
2366 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2368 event_info->cb, event_info->user_data);
2369 } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2371 g_variant_get(parameters, "(i)", &value);
2372 BT_DBG("Value = [%d]\n", value);
2373 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2375 event_info->cb, event_info->user_data);
2376 } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2379 bluetooth_vendor_dep_at_cmd_t cmd;
2380 g_variant_get(parameters, "(i&s)", &value, &msg);
2381 BT_DBG("Value = [%d], message = %s\n", value, msg);
2384 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2386 event_info->cb, event_info->user_data);
2391 static void __bt_remove_all_events(void)
2394 bt_event_info_t *info;
2396 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2400 _bt_unregister_event(info->event_type);
2403 g_slist_free(event_list);
2407 static gboolean __bt_event_is_registered(int event_type)
2410 bt_event_info_t *info;
2412 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2417 if (info->event_type == event_type)
2424 bt_event_info_t *_bt_event_get_cb_data(int event_type)
2427 bt_event_info_t *info;
2429 for (l = event_list; l != NULL; l = g_slist_next(l)) {
2434 if (info->event_type == event_type)
2441 void _bt_add_server(int server_fd)
2443 bt_server_info_t *info;
2445 info = g_new0(bt_server_info_t, 1);
2446 info->server_fd = server_fd;
2448 server_list = g_slist_append(server_list, info);
2451 void _bt_remove_server(int server_fd)
2454 bt_server_info_t *info;
2456 for (l = server_list; l != NULL; l = g_slist_next(l)) {
2461 if (info->server_fd == server_fd) {
2462 server_list = g_slist_remove(server_list, (void *)info);
2469 void _bt_set_obex_server_id(int server_type)
2471 obex_server_id = server_type;
2474 int _bt_get_obex_server_id(void)
2476 return obex_server_id;
2479 int _bt_init_event_handler(void)
2481 if (is_initialized == TRUE) {
2482 BT_ERR("Connection already exist");
2483 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2486 __bt_remove_all_events();
2488 is_initialized = TRUE;
2490 return BLUETOOTH_ERROR_NONE;
2493 int _bt_deinit_event_handler(void)
2495 if (is_initialized == FALSE) {
2496 BT_ERR("Connection dose not exist");
2497 return BLUETOOTH_ERROR_INTERNAL;
2500 __bt_remove_all_events();
2502 if (disable_timer_id > 0) {
2503 g_source_remove(disable_timer_id);
2504 disable_timer_id = 0;
2507 is_initialized = FALSE;
2509 return BLUETOOTH_ERROR_NONE;
2512 static void __bt_event_data_free(void *data)
2514 bt_event_info_t *cb_data = data;
2516 ret_if(cb_data == NULL);
2521 int _bt_register_event(int event_type, void *event_cb, void *user_data)
2523 GDBusConnection *connection_type;
2524 GDBusSignalCallback event_func;
2525 bt_event_info_t *cb_data;
2527 const char *interface = BT_EVENT_SERVICE;
2529 if (is_initialized == FALSE)
2530 _bt_init_event_handler();
2532 if (__bt_event_is_registered(event_type) == TRUE) {
2533 BT_ERR("The event is already registed");
2534 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2537 switch (event_type) {
2538 case BT_ADAPTER_EVENT:
2539 event_func = __bt_adapter_event_filter;
2540 path = BT_ADAPTER_PATH;
2542 case BT_LE_ADAPTER_EVENT:
2543 event_func = __bt_adapter_le_event_filter;
2544 path = BT_LE_ADAPTER_PATH;
2546 case BT_DEVICE_EVENT:
2547 event_func = __bt_device_event_filter;
2548 path = BT_DEVICE_PATH;
2551 event_func = __bt_hid_event_filter;
2554 case BT_HEADSET_EVENT:
2555 event_func = __bt_headset_event_filter;
2556 path = BT_HEADSET_PATH;
2558 case BT_NETWORK_EVENT:
2559 event_func = __bt_network_event_filter;
2560 path = BT_NETWORK_PATH;
2562 case BT_AVRCP_EVENT:
2563 event_func = __bt_avrcp_event_filter;
2564 path = BT_AVRCP_PATH;
2566 case BT_AVRCP_CONTROL_EVENT:
2567 event_func = __bt_avrcp_control_event_filter;
2568 path = BT_AVRCP_CONTROL_PATH;
2570 case BT_OPP_CLIENT_EVENT:
2571 event_func = __bt_opp_client_event_filter;
2572 path = BT_OPP_CLIENT_PATH;
2574 case BT_OPP_SERVER_EVENT:
2575 event_func = __bt_opp_server_event_filter;
2576 path = BT_OPP_SERVER_PATH;
2578 case BT_PBAP_CLIENT_EVENT:
2579 event_func = __bt_pbap_client_event_filter;
2580 path = BT_PBAP_CLIENT_PATH;
2582 case BT_RFCOMM_CLIENT_EVENT:
2583 event_func = __bt_rfcomm_client_event_filter;
2584 path = BT_RFCOMM_CLIENT_PATH;
2586 case BT_RFCOMM_SERVER_EVENT:
2587 event_func = __bt_rfcomm_server_event_filter;
2588 path = BT_RFCOMM_SERVER_PATH;
2590 case BT_HF_AGENT_EVENT:
2591 BT_DBG("BT_HF_AGENT_EVENT\n");
2592 event_func = __bt_hf_agent_event_filter;
2593 path = BT_HF_AGENT_PATH;
2594 interface = BT_HF_SERVICE_INTERFACE;
2596 case BT_A2DP_SOURCE_EVENT:
2597 BT_DBG("BT_A2DP_SOURCE_EVENT");
2598 event_func = __bt_a2dp_source_event_filter;
2599 path = BT_A2DP_SOURCE_PATH;
2601 case BT_HID_DEVICE_EVENT:
2602 BT_DBG("BT_HID_DEVICE_EVENT");
2603 event_func = __bt_hid_device_event_filter;
2604 path = BT_HID_DEVICE_PATH;
2606 #ifdef GATT_NO_RELAY
2607 case BT_GATT_BLUEZ_EVENT:
2608 BT_DBG("BT_GATT_BLUEZ_EVENT");
2609 event_func = __bt_device_event_filter;
2610 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2615 BT_ERR("Unknown event");
2616 return BLUETOOTH_ERROR_INTERNAL;
2619 connection_type = _bt_gdbus_get_system_gconn();
2620 if (connection_type == NULL)
2621 return BLUETOOTH_ERROR_INTERNAL;
2623 cb_data = g_new0(bt_event_info_t, 1);
2625 cb_data->event_type = event_type;
2626 cb_data->cb = event_cb;
2627 cb_data->user_data = user_data;
2629 cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2630 NULL, interface, NULL, path, NULL, 0,
2631 event_func, cb_data, NULL);
2633 event_list = g_slist_append(event_list, cb_data);
2635 return BLUETOOTH_ERROR_NONE;
2638 int _bt_unregister_event(int event_type)
2640 GDBusConnection *connection_type;
2641 bt_event_info_t *cb_data;
2643 if (is_initialized == FALSE) {
2644 BT_ERR("Event is not registered");
2645 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2648 if (__bt_event_is_registered(event_type) == FALSE) {
2649 BT_ERR("Not registered event");
2650 return BLUETOOTH_ERROR_INTERNAL;
2653 cb_data = _bt_event_get_cb_data(event_type);
2655 if (cb_data == NULL) {
2656 BT_ERR("No matched event data");
2657 return BLUETOOTH_ERROR_INTERNAL;
2660 connection_type = _bt_gdbus_get_system_gconn();
2662 event_list = g_slist_remove(event_list, (void *)cb_data);
2664 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2666 g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2668 __bt_event_data_free((void *)cb_data);
2670 return BLUETOOTH_ERROR_NONE;
2673 static void __bt_name_owner_changed(GDBusConnection *connection,
2674 const gchar *sender_name,
2675 const gchar *object_path,
2676 const gchar *interface_name,
2677 const gchar *signal_name,
2678 GVariant *parameters,
2681 const char *name = NULL;
2682 const char *old_owner = NULL;
2683 const char *new_owner = NULL;
2684 bt_event_info_t *event_info;
2686 g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2688 if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2689 (new_owner != NULL && *new_owner == '\0')) {
2690 BT_DBG("bt-service is terminated");
2691 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2692 if (event_info == NULL)
2695 if (disable_timer_id > 0)
2696 g_source_remove(disable_timer_id);
2698 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2699 (GSourceFunc)__bt_reliable_disable_cb,
2704 void _bt_register_name_owner_changed(void)
2706 GDBusConnection *connection_type;
2708 connection_type = _bt_gdbus_get_system_gconn();
2709 if (connection_type == NULL) {
2710 BT_ERR("Unable to get the bus");
2713 owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2714 NULL, DBUS_INTERFACE_DBUS,
2715 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2716 __bt_name_owner_changed, NULL, NULL);
2719 void _bt_unregister_name_owner_changed(void)
2721 GDBusConnection *connection_type;
2723 connection_type = _bt_gdbus_get_system_gconn();
2724 if (connection_type != NULL && owner_sig_id != -1) {
2725 g_dbus_connection_signal_unsubscribe(connection_type,